home *** CD-ROM | disk | FTP | other *** search
/ AppleScript - The Beta Release / AppleScript - The Beta Release.iso / Development Tools / Sample Applications / MenuScripter 1.0d4.1 / MenuScripter Source / MSAppleEvents.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-24  |  175.0 KB  |  6,493 lines  |  [TEXT/MPS ]
  1. /* 
  2.     MSAppleEvents.c 
  3.   
  4.     Version 1.0d4
  5.     
  6.     Copyright © Apple Computer UK Ltd. 1992
  7.     
  8.     All rights reserved
  9.     
  10.     Produced by : UK Developer Technical Support    UK.DTS
  11.     
  12.     The AppleEvent handling routines for the MenuScripter example program
  13.     
  14.     This file includes :
  15.     
  16.         a) the code for the AppleEvent initialisation 
  17.         b) the routines for all the Edition Manager events
  18.         c) the Apple® Event Object Support
  19.  
  20. */
  21.  
  22. /*
  23.     Changes for 1.0d2: 
  24.     
  25.         10-Aug-92 : NH : Fixed Quit save no - AEInteractWithUser called now
  26.                                          Added IssueQuitCommand.
  27.                                          Install cLine from typeMyText accessor
  28.                                          
  29.     Changes for 1.0d3:
  30.     
  31.         21-Aug-92 : NH : Fix hadPlain for offstyles in GetTextStyles
  32.                          Dispose of objTokenDesc in HandleGetData
  33.                                          Use result of BuildStyledTextDesc
  34.                                          nil myDirObj at start of DoGetDataSize
  35.                                          Dispose of selfAddr in IssueCloseCommand
  36.                                          
  37.         27-Aug-92 : NH : Added pBestType and pClass to all classes
  38.          1-Sep-92 : NH : Added factoring of window selection.
  39.                          Added OKToModifySelection and inhibition of 
  40.                                          changes to subscribers.
  41.                                          Fixed pIndex property of window
  42.                                          Changed MakeWindowObj to create formAbsolutePosition, not formName for
  43.                                          better recording.
  44.                                          Ignore all AEDisposeDesc results, return true errors
  45.                                          
  46.     Changes for 1.0d4:
  47.  
  48.         14-Nov-92    : NH : Changed pUserSelection to pSelection
  49. */
  50.  
  51.  
  52. #include <AppleEvents.h>
  53. #include <Sysequ.h>
  54. #include <Menus.h>
  55. #include <PLStringFuncs.h>
  56. #include <Scrap.h>
  57. #include <TextEdit.h>
  58. #include <AEObjects.h>
  59. #include <AEPackObject.h>
  60. #include <AERegistry.h>
  61. #include "MSGlobals.h"
  62. #include "MSUtils.h"
  63. #include "MSAEUtils.h"
  64. #include "MSWindow.h"
  65. #include "MSFile.h"
  66. #include "MSScript.h"
  67. #include "MSAppleEvents.h"
  68.  
  69. /* these should come from the registry */
  70.         
  71. #define         kAEStartedRecording    'rec1'
  72. #define         kAEStoppedRecording         'rec0'
  73. #define         kAEDontExecute                  0x00002000
  74. #define         errCantWriteSubscriber 10000
  75.  
  76. #define         pContents                 'pcnt' // Borrowed from Quill
  77. #define     cSpot             'cspt'
  78.  
  79. /*
  80.     Text Properties
  81. */
  82.         
  83. #define         pStringWidth            'pwid'
  84.         
  85. /*
  86.     Window Properties - See the Registry for Details
  87. */
  88.         
  89. #define     pPosition                'ppos'
  90. #define         pPageSetup                'PSET' /* One of ours - Not in registry */
  91. #define         pShowBorders            'PBOR' /* Another of ours */
  92. #define     pSelection        'sele' /* changed from pUserSelection */
  93.                 
  94. #define         typeTPrint                'TPNT' /* A raw TPrint record - also one of ours */
  95.  
  96. /*
  97.     Menu properties of our own devising
  98. */
  99.  
  100. #define     pActiveItem       'PACT'
  101.  
  102. /*
  103.     Error Codes
  104. */
  105.         
  106. #define         kAEGenericErr    -1799
  107.  
  108. static long   gBigBrother;
  109. static char  *gTypingBuffer;
  110. static short  gCharsInBuffer;
  111. static AEDesc gTypingTargetObject;
  112.  
  113. /*-----------------------------------------------------------------------*/
  114. /**----------                         APPLE EVENT HANDLING                     ---------------**/
  115. /*-----------------------------------------------------------------------*/
  116.  
  117. pascal OSErr GetTHPrintFromDescriptor(const AEDesc *sourceDesc, THPrint *result)
  118.   {
  119.       OSErr   myErr;
  120.         OSErr   ignoreErr;
  121.         Size    ptSize;
  122.         AEDesc  resultDesc;
  123.         
  124.         myErr = AECoerceDesc(sourceDesc,typeTPrint,&resultDesc);
  125.         
  126.         *result = nil;
  127.         
  128.         if (myErr==noErr) 
  129.             {
  130.                 *result = (THPrint)NewHandle(sizeof(TPrint));
  131.                 
  132.                 PrOpen();
  133.                 PrintDefault(*result);
  134.                 
  135.                 HLock((Handle)*result);
  136.     
  137.                 GetRawDataFromDescriptor(&resultDesc,
  138.                                                                  (Ptr)**result,
  139.                                                                  sizeof(TPrint),
  140.                                                                  &ptSize);
  141.                                                                  
  142.                 HUnlock((Handle)*result);
  143.                 
  144.                 if ((ptSize<sizeof(TPrint)) || (PrValidate(*result)))
  145.                     {
  146.                         myErr = errAECoercionFail;
  147.                         DisposHandle((Handle)*result);
  148.                         *result = nil;
  149.                     }
  150.                 
  151.                 PrClose();
  152.             }
  153.         
  154.         if (resultDesc.dataHandle) 
  155.             ignoreErr = AEDisposeDesc(&resultDesc);
  156.             
  157.         return(myErr);
  158.     } /*GetTHPrintFromDescriptor*/
  159.  
  160. /*******************************************************************************/
  161. /*
  162.     Object Accessors - Utility Routines
  163. */
  164.  
  165. #pragma segment ObjectAccessors
  166.  
  167. pascal WindowPtr WindowNameToWindowPtr(StringPtr nameStr)
  168. /* 
  169.     Returns the WindowPtr of the window with title nameStr
  170.     or nil if there is no matching window.
  171. */
  172.     { 
  173.         WindowPtr theWindow;
  174.         Str255    windTitle;
  175.             
  176.         theWindow = (WindowPtr)*((Handle)WindowList);
  177.         /* 
  178.             iterate through windows - we use WindowList 'cos we could
  179.             have made the window invisible and  we lose it - so we
  180.             can't set it back to visible!!
  181.         */
  182.         while (theWindow)
  183.             {
  184.                 GetWTitle(theWindow, windTitle);
  185.                 if (EqualString(windTitle,
  186.                                 nameStr,
  187.                                                 false,
  188.                                                 true))     /* ignore case, don't ignore diacriticals */
  189.                     return(theWindow);
  190.               theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  191.             }
  192.         return(theWindow);
  193.     }    /* WindowNameToWindowPtr */
  194.  
  195. pascal WindowPtr GetWindowPtrOfNthWindow(short index)
  196. /* returns a ptr to the window with the given index
  197.   (front window is 1, behind that is 2, etc.).  if
  198.   there's no window with that index (inc. no windows
  199.   at all), returns nil.
  200. */
  201.   {
  202.       WindowPtr theWindow;
  203.         
  204.         theWindow = (WindowPtr)*((Handle)WindowList);
  205.     
  206.         /* iterate through windows */
  207.         
  208.         while (theWindow)
  209.             {
  210.                 index --;
  211.                 if (index <= 0) 
  212.                     return(theWindow);
  213.                     
  214.               theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  215.             }
  216.         return(nil);
  217.     }    /* GetWindowPtrOfNthWindow */
  218.     
  219. pascal short CountWindows(void)
  220.     {
  221.         WindowPtr theWindow;
  222.         short     index;
  223.                 
  224.         index = 0;
  225.         theWindow = (WindowPtr)*((Handle)WindowList);
  226.     
  227.         /* iterate through windows */
  228.         
  229.         while (theWindow)
  230.             {
  231.                 index++;                    
  232.               theWindow = (WindowPtr)((WindowPeek)theWindow)->nextWindow;
  233.             }
  234.         
  235.         return(index);
  236.         
  237.     } /*CountWindows*/
  238.     
  239. pascal short ItemForNamedFont(Str255 theName)
  240.     {
  241.       Str255  itemName;
  242.         short   limit;
  243.     
  244.         limit = CountMItems(myMenus[fontM]);
  245.         while (limit>0)
  246.             {
  247.                 GetItem(myMenus[fontM],limit, itemName);
  248.                 if (IUEqualString(theName, itemName)==0) 
  249.                     return(limit);
  250.                 else
  251.                     limit--;
  252.             }
  253.         return(0);
  254.     } /*ItemForNamedFont*/
  255.  
  256. /**-----------------------------------------------------------------------
  257.         Name:             DoOpenApp
  258.         Purpose:        Called on startup, creates a new document.
  259.     -----------------------------------------------------------------------**/
  260.  
  261. #pragma segment Main
  262.  
  263. pascal OSErr DoOpenApp(const AppleEvent *message,const AppleEvent *reply,long refcon)
  264.   {
  265. #pragma unused (reply,refcon, message)
  266.     
  267.       DPtr ourDoc;
  268.     
  269.         /*just create a new document*/
  270.         ourDoc = NewDocument(false);
  271.         
  272.         if (ourDoc)
  273.             {
  274.                 ShowWindow(ourDoc->theWindow);
  275.                 return(noErr);
  276.             }
  277.         else
  278.             return(-108);
  279.     }
  280.  
  281. /**-----------------------------------------------------------------------
  282.         Name:             DoOpenDocument
  283.         Purpose:        Open all the documents passed in the Open AppleEvent.
  284. -----------------------------------------------------------------------**/
  285.  
  286. #pragma segment Main
  287.  
  288. pascal OSErr DoOpenDocument(const AppleEvent *message, const AppleEvent *reply, long refcon)            
  289.   {
  290. #pragma unused (reply, refcon)
  291.  
  292.         long        index;
  293.         long        itemsInList;
  294.         AEKeyword   keywd;
  295.         OSErr       err;
  296.         OSErr       ignoreErr;
  297.         AEDescList  docList;
  298.         long        actSize;
  299.         DescType    typeCode;
  300.         FSSpec      theFSSpec;
  301.         
  302.         /*open the specified documents*/
  303.         
  304.         docList.dataHandle = nil;
  305.         
  306.         err = AEGetParamDesc(message, keyDirectObject, typeAEList, &docList);
  307.         
  308.         if (err==noErr)
  309.             err = AECountItems( &docList, &itemsInList) ;
  310.         else
  311.           itemsInList = 0;
  312.             
  313.         for (index = 1; index <= itemsInList; index++)
  314.             if (err==noErr)
  315.                 {
  316.                     err = AEGetNthPtr( &docList, index, typeFSS, &keywd, &typeCode,
  317.                                                          (Ptr)&theFSSpec, sizeof(theFSSpec), &actSize ) ;
  318.                     if (err==noErr)
  319.                       err = OpenOld(theFSSpec);
  320.                 }
  321.     
  322.       if (docList.dataHandle)
  323.             ignoreErr = AEDisposeDesc(&docList);
  324.             
  325.         return(err);
  326.     }
  327.  
  328. /**-----------------------------------------------------------------------
  329.         Name:             MyQuit
  330.         Purpose:        Quit event received- exit the program.
  331.     -----------------------------------------------------------------------**/
  332.  
  333. #pragma segment Main
  334.  
  335. pascal OSErr MyQuit(const AppleEvent *message,const AppleEvent *reply,long refcon)            
  336.     {
  337. #pragma unused (reply,refcon)
  338.     
  339.         DescType saveOpt;
  340.         OSErr    tempErr;
  341.         OSErr    myErr;
  342.         DescType returnedType;
  343.         long     actSize;
  344.         
  345.         saveOpt = kAEAsk; /* the default */
  346.         tempErr = AEGetParamPtr(message,
  347.                                                         keyAESaveOptions,
  348.                                                         typeEnumerated,
  349.                                                         &returnedType,
  350.                                                         (Ptr)&saveOpt,
  351.                                                         sizeof(saveOpt),
  352.                                                         &actSize);
  353.         
  354.         if (saveOpt != kAENo)
  355.             myErr = AEInteractWithUser(kAEDefaultTimeout, nil, nil);
  356.  
  357.       if (myErr == noErr)
  358.             DoQuit(saveOpt);
  359.         
  360.         return(myErr);
  361.     }
  362.  
  363. /**-----------------------------------------------------------------------
  364.         Name:             DoAppleEvent
  365.         Purpose:        Process and despatch the AppleEvent
  366.     -----------------------------------------------------------------------**/
  367.  
  368. #pragma segment Main
  369.  
  370. pascal void DoAppleEvent(EventRecord theEvent)
  371.   {
  372.       OSErr err;
  373.         
  374.       /*should check for your own event message types here - if you have any*/
  375.  
  376.         err = AEProcessAppleEvent(&theEvent);
  377.     }
  378.  
  379. /**-----------------------------------------------------------------------
  380.         Name:             MakeSelfAddress
  381.         Purpose:        Builds an AEAddressDesc for the current process
  382.     -----------------------------------------------------------------------**/
  383.     
  384. pascal OSErr MakeSelfAddress(AEAddressDesc *selfAddress)
  385.   {
  386.       ProcessSerialNumber procSerNum;
  387.     
  388.         procSerNum.highLongOfPSN = 0;
  389.         procSerNum.lowLongOfPSN  = kCurrentProcess;
  390.         
  391.         return(AECreateDesc(typeProcessSerialNumber,
  392.                                                 (Ptr)&procSerNum,
  393.                                               sizeof(procSerNum),
  394.                                                 selfAddress));
  395.         
  396.     } /* MakeSelfAddress */
  397.  
  398. /**--------------------------------------------------------------------
  399.     Name : SendAESetObjProp
  400.     Function : Creates a property object from an object,
  401.                          a property type and its data and sends it to
  402.                          the requested address, and cleans up zapping params too
  403.     --------------------------------------------------------------------**/
  404.  
  405. pascal OSErr SendAESetObjProp(AEDesc        *theObj,
  406.                                                             DescType      theProp,
  407.                                                             AEDesc        *theData,
  408.                                                             AEAddressDesc *toWhom)
  409.                                                      
  410.     {
  411.        AEDesc     propObjSpec;
  412.          AppleEvent myAppleEvent;
  413.          AppleEvent defReply;
  414.          OSErr      myErr;
  415.          OSErr      ignoreErr;
  416.          AEDesc     theProperty;
  417.             
  418.         /* create an object spec that represents the property of the given object */
  419.         
  420.         myErr = AECreateDesc(typeType,
  421.                                                  (Ptr)&theProp,
  422.                                                  sizeof(theProp),
  423.                                                  &theProperty);
  424.         if (myErr==noErr)
  425.             myErr = CreateObjSpecifier(cProperty,
  426.                                                                  theObj,
  427.                                                                  formPropertyID,
  428.                                                                  &theProperty,
  429.                                                                  true,
  430.                                                                  &propObjSpec);    
  431.             
  432.         /* create event */
  433.         
  434.         if (myErr==noErr)
  435.             myErr = AECreateAppleEvent(kAECoreSuite,
  436.                                                                  kAESetData,
  437.                                                                  toWhom,
  438.                                                                  0,
  439.                                                                  0,
  440.                                                                  &myAppleEvent);
  441.             
  442.         /* add prop obj spec to the event */
  443.         
  444.         if (myErr==noErr)
  445.             myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, &propObjSpec);
  446.         
  447.         /* add prop data to the event */
  448.         
  449.         if (myErr==noErr)
  450.             myErr = AEPutParamDesc(&myAppleEvent,keyAEData, theData);
  451.         
  452.         /* send event */
  453.         
  454.         if (myErr==noErr)
  455.             myErr = AESend(&myAppleEvent,
  456.                                          &defReply,
  457.                                          kAENoReply+kAEAlwaysInteract,
  458.                                          kAENormalPriority,
  459.                                          kAEDefaultTimeout,
  460.                                          nil,
  461.                                          nil);
  462.         
  463.         if (myAppleEvent.dataHandle)
  464.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  465.             
  466.         if (&propObjSpec.dataHandle)
  467.           ignoreErr = AEDisposeDesc(&propObjSpec);
  468.         
  469.         if (theData->dataHandle)
  470.             ignoreErr = AEDisposeDesc(theData);
  471.         
  472.         if (toWhom->dataHandle)
  473.             ignoreErr = AEDisposeDesc(toWhom);
  474.         
  475.         return(myErr);
  476.         
  477.     }    /* SendAESetObjProp */
  478.  
  479. /*----------------------------------------------------------------------------------------------*/
  480. /*
  481.     Private AEObject definitions
  482. */
  483. #pragma segment AECommandHandlers
  484.  
  485. #define typeMyAppl       'BAPP' /* sig of my private token type for the app     - appToken   */
  486. #define typeMyWndw             'BWIN'    /* sig of my private token type for windows     - windowToken   */
  487. #define typeMyText           'BTXT'    /* sig of my private token type for text        - textToken     */
  488. #define typeMyTextProp   'BPRP'    /* sig of my private token type for text properties    - textPropToken */
  489. #define typeMyWindowProp 'WPRP'    /* sig of my private token type for window properties  - windowPropToken */
  490. #define typeMyApplProp   'APRP'    /* sig of my private token type for appl properties    - applPropToken */
  491. #define typeMyMenu       'MTKN' /* sig of my private token type for menus       - menuToken  */
  492. #define typeMyMenuItem   'ITKN' /* sig of my private token type for menus       - menuItemToken  */
  493. #define typeMyMenuProp   'MPRP' /* sig of my private token type for menu properties - menuPropToken  */
  494. #define typeMyItemProp   'IPRP' /* sig of my private token type for menu item properties  - menuItemPropToken  */
  495.     
  496. /* These are entirely private to our app - used only when resolving the object specifier */
  497.     
  498. typedef    ProcessSerialNumber appToken;
  499.     
  500. struct applPropToken{
  501.     appToken tokenApplToken;
  502.     DescType tokenApplProperty;
  503. };
  504.  
  505. typedef struct applPropToken applPropToken;
  506.                                         
  507. typedef    WindowPtr WindowToken;
  508.     
  509. struct windowPropToken{
  510.         WindowToken tokenWindowToken;
  511.         DescType    tokenProperty;
  512.     };
  513.     
  514. typedef struct windowPropToken windowPropToken;
  515.     
  516. struct TextToken{
  517.         WindowPtr tokenWindow;
  518.         short     tokenOffset;
  519.         short     tokenLength;
  520.     };
  521.                     
  522. typedef struct TextToken TextToken;
  523.  
  524. struct textPropToken{
  525.         TextToken propertyTextToken;
  526.         DescType  propertyProperty;
  527.     };
  528.                 
  529. typedef struct textPropToken textPropToken;
  530.  
  531. /* Tokens related to menus */
  532.  
  533. struct MenuToken {
  534.     MenuHandle theTokenMenu;
  535.     short      theTokenID;
  536. };
  537.  
  538. typedef struct MenuToken MenuToken;
  539.  
  540. struct MenuItemToken {
  541.     MenuToken  theMenuToken;
  542.     short      theTokenItem;
  543. };
  544.  
  545. typedef struct MenuItemToken MenuItemToken;
  546.  
  547. struct MenuPropToken {
  548.     MenuToken  theMenuToken;
  549.     DescType   theMenuProp;
  550. };
  551.  
  552. typedef struct MenuPropToken MenuPropToken;
  553.  
  554. struct MenuItemPropToken {
  555.     MenuItemToken  theItemToken;
  556.     DescType       theItemProp;
  557. };
  558.  
  559. typedef struct MenuItemPropToken MenuItemPropToken;
  560.  
  561. /*
  562.     Name: GotRequiredParams
  563.     Function: Checks all parameters defined as 'required' have been read
  564. */                            
  565. pascal OSErr GotRequiredParams(const AppleEvent *theAppleEvent)
  566.     {
  567.       OSErr    myErr;
  568.         DescType returnedType;
  569.         Size     actSize;
  570.         
  571.         /* look for the keyMissedKeywordAttr, just to see if it's there */
  572.         
  573.         myErr = AEGetAttributePtr(theAppleEvent,
  574.                                                             keyMissedKeywordAttr,
  575.                                                             typeWildCard,
  576.                                                             &returnedType,
  577.                                                             nil,
  578.                                                             0,
  579.                                                             &actSize);
  580.         
  581.         if (myErr == errAEDescNotFound) 
  582.             return(noErr);            /* attribute not there means we got all req params */
  583.         else 
  584.             if (myErr == noErr)  
  585.                 return(errAEParamMissed);        /* attribute there means missed at least one */
  586.             else 
  587.                 return(myErr);        /* some unexpected arror in looking for the attribute */
  588.     }    /* GotReqiredParams */
  589.  
  590. /**--------------------------------------------------------------------
  591.     Name : SetSelectionOfAppleEventDirectObject
  592.     Function : Resolves the Direct Object into a text token and
  593.                          sets the selection of the specified document to that
  594.                          specified in the direct object.
  595.                          Returns the doc and TEHandle chosen.
  596.     --------------------------------------------------------------------**/
  597.  
  598. pascal OSErr SetSelectionOfAppleEventDirectObject(const AppleEvent *theAppleEvent,
  599.                                                                                                DPtr             *theDocument,
  600.                                                                                                 TEHandle         *theHTE)
  601.     {
  602.         OSErr     myErr;
  603.         DescType  returnedType;
  604.         long      actSize;
  605.         TextToken myTextToken;
  606.         OSErr     paramErr;
  607.         WindowPtr fWin;
  608.                     
  609.         paramErr = AEGetParamPtr( theAppleEvent,
  610.                                                             keyDirectObject,
  611.                                                             typeMyText,
  612.                                                             &returnedType,
  613.                                                       (Ptr)&myTextToken,
  614.                                                             sizeof(myTextToken),
  615.                                                             &actSize);
  616.               
  617.         myErr = GotRequiredParams(theAppleEvent);
  618.         
  619.         /* now let's work on the direct object, if any */
  620.         
  621.         if (paramErr == errAEDescNotFound) 
  622.             {
  623.                 /* no direct object; check we have a window */
  624.                 
  625.                 fWin = FrontWindow();
  626.  
  627.                 if (fWin == nil) 
  628.                     return(-1700); /* Generic Err */
  629.                     
  630.                 *theDocument = DPtrFromWindowPtr(fWin);
  631.                 *theHTE      = (**theDocument).theText;
  632.             }
  633.         
  634.         if (paramErr == noErr) 
  635.             {
  636.                 /* got a text token */
  637.                 
  638.                 *theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  639.                 *theHTE      = (**theDocument).theText;
  640.                 
  641.                 TESetSelect(myTextToken.tokenOffset-1,
  642.                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  643.                                         *theHTE);
  644.                 
  645.             }
  646.             
  647.         if ((paramErr!=noErr) &&
  648.             (paramErr!=errAEDescNotFound))
  649.              {
  650.                  *theDocument = DPtrFromWindowPtr(FrontWindow());
  651.                  *theHTE      = (**theDocument).theText;
  652.              }
  653.              
  654.      return(myErr);
  655.      
  656.     } /* SetSelectionOfAppleEventDirectObject */
  657.     
  658. /**--------------------------------------------------------------------
  659.     Name             : SetSelectionOfAppleEventObject
  660.     Function     : Resolves the whatObject type of the AppleEvent into a text
  661.                              token and sets the selection to be that specified in the
  662.                              text token.
  663.                              Returns the doc and TEHandle chosen.
  664.     --------------------------------------------------------------------**/
  665.  
  666. pascal OSErr SetSelectionOfAppleEventObject(OSType            whatObject,
  667.                                                                                     const AppleEvent *theAppleEvent,
  668.                                                                                      DPtr             *theDocument,
  669.                                                                                     TEHandle         *theHTE)
  670.     {
  671.         DescType   returnedType;
  672.         long       actSize;
  673.         TextToken  myTextToken;
  674.         OSErr      paramErr;
  675.             
  676.         paramErr  = AEGetParamPtr(theAppleEvent,
  677.                                                             whatObject,
  678.                                                             typeMyText,
  679.                                                             &returnedType,
  680.                                                       (Ptr)&myTextToken,
  681.                                                             sizeof(myTextToken),
  682.                                                             &actSize);
  683.                                       
  684.         if (paramErr == noErr) 
  685.             {
  686.                 /* got a text token */
  687.                 
  688.                 *theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  689.                 *theHTE      = (**theDocument).theText;
  690.                 
  691.                 TESetSelect(myTextToken.tokenOffset-1,
  692.                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  693.                                         *theHTE);
  694.             }
  695.                              
  696.         return(paramErr);
  697.                  
  698.     } /* SetSelectionOfAppleEventObject */
  699.     
  700. /* -----------------------------------------------------------------------
  701.         Name:             AddErrorTextToReply
  702.         Purpose:        Adds the text to cannot modify subscriber
  703.      -----------------------------------------------------------------------**/
  704.      
  705. pascal void AddErrorTextToReply(const Str255 theText, AppleEvent *reply)
  706.     {
  707.         OSErr myErr;
  708.         
  709.         if (reply->descriptorType!=typeNull)
  710.             myErr = AEPutParamPtr(reply,
  711.                             keyErrorString,
  712.                             typeChar,
  713.                             (Ptr) &theText[1],
  714.                             theText[0]);
  715.     }
  716.     
  717. /* -----------------------------------------------------------------------
  718.         Name:             DoCutEdit
  719.         Purpose:        Performs a cut text operation on the current text selection
  720.      -----------------------------------------------------------------------**/
  721.     
  722. pascal OSErr DoCutEdit(const AppleEvent *theAppleEvent, AppleEvent *reply ,long refCon)
  723.     {
  724. #pragma unused (reply,refCon)
  725.     
  726.       OSErr    myErr;
  727.       TEHandle theHTE;
  728.         DPtr     theDocument;
  729.     
  730.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent,&theDocument,&theHTE);
  731.         
  732.         if (myErr==noErr) 
  733.             {            
  734.                 myErr = (OSErr) ZeroScrap();
  735.                 
  736.                 if (OKToModifySelection(theDocument))
  737.                     {
  738.                         DoTECutSectionRecalc(theDocument);
  739.                         TECut(theHTE);
  740.                         
  741.                         RecalcChangedSectionBorders(theDocument);
  742.                         AdjustScrollbars(theDocument, false);
  743.                         DrawPageExtras(theDocument);
  744.                         theDocument->dirty = true;
  745.                     }
  746.                 else
  747.                     {
  748.                         myErr = errCantWriteSubscriber;
  749.                         AddErrorTextToReply("\pCannot write into subscriber", reply);
  750.                     }
  751.             }
  752.             
  753.         return(myErr);
  754.     } /* DoCutEdit */
  755.     
  756. /* -----------------------------------------------------------------------
  757.         Name:             DoCopyEdit
  758.         Purpose:        Performs a copy text operation on the text selection specified
  759.                                 by the appleEvent direct object (if any)
  760.      -----------------------------------------------------------------------**/
  761.     
  762. pascal OSErr DoCopyEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refCon)
  763.     {
  764. #pragma unused (reply,refCon)
  765.     
  766.       OSErr    myErr;
  767.         TEHandle theHTE;
  768.         DPtr     theDocument;
  769.  
  770.         /*
  771.                 Here we extract the information about what to copy from the
  772.                 directObject - if any
  773.         */
  774.         
  775.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent,&theDocument,&theHTE);
  776.         
  777.         if (myErr==noErr) 
  778.             {
  779.                 myErr = (OSErr) ZeroScrap();
  780.                 TECopy(theHTE);     
  781.             }
  782.             
  783.         if (myErr==noErr) 
  784.             {
  785.                 myErr = SetSelectionOfAppleEventObject(keyAEContainer, 
  786.                                                                                              theAppleEvent,
  787.                                                                                              &theDocument,
  788.                                                                                              &theHTE);
  789.                 if (myErr == noErr) 
  790.                     if (OKToModifySelection(theDocument))
  791.                         {
  792.                             DoTEPasteSectionRecalc(theDocument);
  793.                             
  794.                             TEStylPaste(theHTE);
  795.                             
  796.                             RecalcChangedSectionBorders(theDocument);
  797.                             AdjustScrollbars(theDocument, false);
  798.                             DrawPageExtras(theDocument);
  799.                             
  800.                             theDocument->dirty = true;
  801.                         }
  802.                     else
  803.                         {
  804.                             myErr = errCantWriteSubscriber;
  805.                             AddErrorTextToReply("\pCannot write into subscriber", reply);
  806.                         }
  807.             }
  808.             
  809.         return(myErr);
  810.     } /* DoCopyEdit */
  811.     
  812. /* -----------------------------------------------------------------------
  813.         Name:             DoPasteEdit
  814.         Purpose:        Performs a paste text operation on the text selection specified
  815.                                 by the appleEvent direct object (if any)
  816.      -----------------------------------------------------------------------**/
  817.     
  818. pascal OSErr DoPasteEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refCon)
  819.     {
  820. #pragma unused (reply,refCon)
  821.     
  822.       OSErr    myErr;
  823.         TEHandle theHTE;
  824.         DPtr     theDocument;
  825.  
  826.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent, &theDocument, &theHTE);
  827.         
  828.         if (myErr==noErr) 
  829.             if (OKToModifySelection(theDocument))
  830.                 {
  831.                     DoTEPasteSectionRecalc(theDocument);
  832.                     
  833.                     TEStylPaste(theHTE);     
  834.                     
  835.                     RecalcChangedSectionBorders(theDocument);
  836.                     AdjustScrollbars(theDocument, false);
  837.                     DrawPageExtras(theDocument);
  838.     
  839.                     theDocument->dirty = true;
  840.                 }
  841.             else
  842.                 {
  843.                     myErr = errCantWriteSubscriber;
  844.                     AddErrorTextToReply("\pCannot write into subscriber", reply);
  845.                 }
  846.             
  847.         return(myErr);
  848.     } /* DoPasteEdit */
  849.     
  850. /* -----------------------------------------------------------------------
  851.         Name:             DoDeleteEdit
  852.         Purpose:        Performs a delete text operation on the selection specified
  853.                                 by the appleEvent direct object (if any)
  854.      -----------------------------------------------------------------------**/
  855.      
  856. pascal OSErr DoDeleteEdit(const AppleEvent *theAppleEvent,AppleEvent *reply, long refcon)
  857.     {
  858. #pragma unused (reply,refcon)
  859.     
  860.         OSErr     myErr;
  861.         TEHandle theHTE;
  862.         DPtr     theDocument;
  863.             
  864.         myErr = SetSelectionOfAppleEventDirectObject(theAppleEvent, &theDocument, &theHTE);
  865.         
  866.         if (myErr==noErr)
  867.             if (OKToModifySelection(theDocument))
  868.                 {
  869.                     DoTEDeleteSectionRecalc(theDocument);
  870.                             
  871.                     TEDelete(theHTE);
  872.                     
  873.                     RecalcChangedSectionBorders(theDocument);
  874.                     theDocument->dirty = true;
  875.                     AdjustScrollbars(theDocument, false);
  876.                     DrawPageExtras(theDocument);
  877.                 }
  878.             else
  879.                 {
  880.                     myErr = errCantWriteSubscriber;
  881.                     AddErrorTextToReply("\pCannot write into subscriber", reply);
  882.                 }
  883.                 
  884.         return(myErr);
  885.     } /*DoDeleteEdit*/
  886.     
  887. /* -----------------------------------------------------------------------
  888.         Name:             SetTheFontOfTheTokenText
  889.         Purpose:        Sets the font of the text specified by theTextToken to 
  890.                                 the font in name.
  891.      -----------------------------------------------------------------------**/
  892.      
  893. pascal OSErr SetTheFontOfTheTokenText(TextToken theTextToken, Str255 name)
  894.     {
  895.       DPtr      theDocument;
  896.         short     theNumber;
  897.         short     theItem;
  898.         GrafPtr   oldPort;
  899.         TextStyle newStyle;
  900.         OSErr     myErr;
  901.     
  902.         myErr = noErr;
  903.         GetPort(&oldPort);
  904.         
  905.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  906.                 
  907.         GetFNum(name, &theNumber);
  908.         
  909.         theItem = ItemForNamedFont(name); /* returns 0 if failed - i.e. SystemFont */
  910.         
  911.         if (gFontMItem)
  912.             CheckItem(myMenus[fontM], gFontMItem, false);
  913.         
  914.         gFontMItem = theItem;
  915.         CheckItem(myMenus[fontM], gFontMItem, true);
  916.         
  917.         theDocument->theFont = theNumber;
  918.         
  919.         TESetSelect(theTextToken.tokenOffset-1,
  920.                                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  921.                                 theDocument->theText);
  922.         
  923.         if (OKToModifySelection(theDocument))
  924.             {
  925.                 newStyle.tsFont = theNumber;
  926.                 TESetStyle(doFont, &newStyle, true, theDocument->theText); 
  927.                 
  928.                 AdjustScrollbars(theDocument, false);
  929.                 DrawPageExtras(theDocument);
  930.                 theDocument->dirty = true;
  931.             }
  932.         else
  933.             myErr = errCantWriteSubscriber;
  934.             
  935.         SetPort(oldPort);
  936.     
  937.         return(myErr);
  938.     } /* SetTheFontOfTheTokenText */
  939.     
  940. /* -----------------------------------------------------------------------
  941.         Name:             SetTheSizeOfTheTokenText
  942.         Purpose:        Sets the size of the text specified by theTextToken to 
  943.                                 the size in theSize.
  944.      -----------------------------------------------------------------------**/
  945.      
  946. pascal OSErr SetTheSizeOfTheTokenText(TextToken theTextToken, short theSize)
  947.     {
  948.         DPtr      theDocument;
  949.         GrafPtr   oldPort;
  950.         TextStyle newStyle;
  951.         OSErr     myErr;
  952.     
  953.         myErr = noErr;
  954.         GetPort(&oldPort);
  955.         
  956.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  957.                                 
  958.         theDocument->theSize = theSize;
  959.         
  960.         TESetSelect(theTextToken.tokenOffset-1,
  961.                                 theTextToken.tokenOffset+theTextToken.tokenLength-1,
  962.                                 theDocument->theText);
  963.         
  964.         if (OKToModifySelection(theDocument))
  965.             {
  966.                 newStyle.tsSize = theSize;
  967.                 TESetStyle(doSize, &newStyle, true, theDocument->theText); 
  968.                 
  969.                 AdjustScrollbars(theDocument, false);
  970.                 DrawPageExtras(theDocument);
  971.                 theDocument->dirty = true;
  972.             }
  973.         else
  974.             myErr = errCantWriteSubscriber;
  975.             
  976.         SetPort(oldPort);
  977.         return(myErr);
  978.     } /* SetTheSizeOfTheTokenText */
  979.     
  980. /* -----------------------------------------------------------------------
  981.         Name:             SetTheStyleOfTheTokenText
  982.         Purpose:        Sets the style of the text specified by theTextToken to 
  983.                                 the style in theStyle.
  984.      -----------------------------------------------------------------------**/
  985.      
  986. pascal OSErr SetTheStyleOfTheTokenText(const TextToken *theTextToken, Style onStyle, Style offStyle)
  987.     {
  988.       DPtr      theDocument;
  989.         GrafPtr   oldPort;
  990.         TextStyle newStyle;
  991.         short     mode;
  992.         Boolean   wasContinuous;
  993.         OSErr     myErr;
  994.     
  995.         myErr = noErr;
  996.         
  997.         GetPort(&oldPort);
  998.         
  999.         theDocument = DPtrFromWindowPtr(theTextToken->tokenWindow);
  1000.                                 
  1001.         theDocument->theStyle = onStyle;
  1002.         TESetSelect(theTextToken->tokenOffset-1,
  1003.                                 theTextToken->tokenOffset+theTextToken->tokenLength-1,
  1004.                                 theDocument->theText);
  1005.         
  1006.         if (!OKToModifySelection(theDocument))
  1007.             return(errCantWriteSubscriber);
  1008.  
  1009.         // Check to see if off styles are on for whole selection
  1010.         mode = doFace;
  1011.         
  1012.         wasContinuous = TEContinuousStyle(&mode, &newStyle, theDocument->theText);
  1013.         if ((newStyle.tsFace & offStyle) != offStyle) // not off styles are on for all
  1014.             {
  1015.               // switch on across board so that toggle off will clear all
  1016.             newStyle.tsFace  = offStyle - (newStyle.tsFace & offStyle);
  1017.                 TESetStyle(doFace+doToggle, &newStyle, false, theDocument->theText); 
  1018.             }
  1019.             
  1020.         newStyle.tsFace  = offStyle;
  1021.         TESetStyle(doFace+doToggle, &newStyle,(onStyle==0), theDocument->theText); // toggle all to off
  1022.         
  1023.         mode = doFace;
  1024.         if (onStyle)
  1025.             {
  1026.                 wasContinuous = TEContinuousStyle(&mode, &newStyle, theDocument->theText);
  1027.                 if ((newStyle.tsFace & onStyle) != onStyle) // are they on for only a few chars
  1028.                     { 
  1029.                         // Need to make all chars have these characteristics
  1030.                     
  1031.                         newStyle.tsFace = onStyle - (newStyle.tsFace & onStyle); // take out those continuous
  1032.                         TESetStyle(doFace+doToggle, &newStyle, true, theDocument->theText);
  1033.                     }
  1034.                 else
  1035.                     TESetStyle(0, &newStyle, true, theDocument->theText); // Just Draw it, no changes
  1036.             }
  1037.             
  1038.         AdjustScrollbars(theDocument, false);
  1039.         DrawPageExtras(theDocument);
  1040.         theDocument->dirty = true;
  1041.         
  1042.         SetPort(oldPort);
  1043.         
  1044.         return(myErr);
  1045.     } /* SetTheStyleOfTheTokenText */
  1046.  
  1047. /* -----------------------------------------------------------------------
  1048.         Name:             SetWindowProperty
  1049.         Purpose:        Sets the window property specified in theWindowPropToken to
  1050.                                 be that supplied in dataDesc.
  1051.      -----------------------------------------------------------------------**/
  1052.      
  1053. pascal OSErr SetWindowProperty(const AEDesc *theWPTokenDesc, const AEDesc *dataDesc)
  1054.     {
  1055.       Str255          theNewName;
  1056.         DPtr            theDocument;
  1057.         OSErr           err;
  1058.         OSErr           ignoreErr;
  1059.         Rect            thePosnRect;
  1060.         Boolean         theBoolean;
  1061.         TEHandle        theHTE;
  1062.         GrafPtr         oldPort;
  1063.         Point           thePosn;
  1064.         THPrint         theTHPrint;
  1065.         windowPropToken theWindowPropToken;
  1066.         AEDesc          newDesc;
  1067.         AEDesc          tokenDesc;
  1068.         Size            tokenSize;
  1069.         TextToken       myTextToken;
  1070.         short           hOffset;
  1071.         short           vOffset;
  1072.  
  1073.         err = AECoerceDesc(theWPTokenDesc, typeMyWindowProp, &newDesc);
  1074.         
  1075.         if (err)
  1076.             return(err);
  1077.  
  1078.         GetRawDataFromDescriptor(&newDesc,
  1079.                                                          (Ptr)&theWindowPropToken,
  1080.                                                          sizeof(theWindowPropToken),
  1081.                                                          &tokenSize);
  1082.         
  1083.         ignoreErr = AEDisposeDesc(&newDesc);
  1084.     
  1085.         GetPort(&oldPort);
  1086.         SetPort(theWindowPropToken.tokenWindowToken);
  1087.         
  1088.         theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  1089.         
  1090.         switch (theWindowPropToken.tokenProperty) {
  1091.         
  1092.             case pName:
  1093.                             err = GetPStringFromDescriptor(dataDesc, (char *)theNewName);
  1094.                             if (err==noErr) 
  1095.                                 if (theNewName[0] == 0) 
  1096.                                     err = errAEWrongDataType;
  1097.                                 else
  1098.                                     {
  1099.                                         SetWTitle(theWindowPropToken.tokenWindowToken, theNewName);
  1100.                                         PLstrcpy(theDocument->theFileName, theNewName); /* Should we do this??? */
  1101.                                         theDocument->dirty = true;
  1102.                                     }
  1103.                             break;
  1104.             
  1105.             case pContents:
  1106.                             theHTE = theDocument->theText;
  1107.                             TESetSelect(0, 32000, theHTE);
  1108.                             
  1109.                             if (OKToModifySelection(theDocument))
  1110.                                 {
  1111.                                     DoTEDeleteSectionRecalc(theDocument);
  1112.                                     TEDelete(theHTE);
  1113.                                     err = GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1114.                                     RecalcChangedSectionBorders(theDocument);
  1115.                                     theDocument->dirty = true;
  1116.                                 }
  1117.                             else
  1118.                                 err = errCantWriteSubscriber;
  1119.                             break;
  1120.                             
  1121.             case pBounds:
  1122.                             err = GetRectFromDescriptor(dataDesc, &thePosnRect);
  1123.                             /* the rectangle is for the structure region, and is in global coordinates */
  1124.                             /* MoveWindow and SizeWindow apply to the content region, so we have to massage a little */
  1125.             
  1126.                             thePosnRect.top    += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.top -
  1127.                                                                         (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.top;
  1128.                                                                         
  1129.                             thePosnRect.left   += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.left -
  1130.                                                                         (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.left;
  1131.                                                                         
  1132.                             thePosnRect.bottom += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.bottom -
  1133.                                                                         (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.bottom;
  1134.                                                                         
  1135.                             thePosnRect.right  += (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.right -
  1136.                                                                         (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.right;
  1137.                             
  1138.                             if (EmptyRect(&thePosnRect)) 
  1139.                                 err = errAECorruptData;
  1140.                             else
  1141.                                 {
  1142.                                     MoveWindow(theWindowPropToken.tokenWindowToken,
  1143.                                                          thePosnRect.left,
  1144.                                                          thePosnRect.top,
  1145.                                                          false);
  1146.                                     SizeWindow(theWindowPropToken.tokenWindowToken,
  1147.                                                          thePosnRect.right- thePosnRect.left,
  1148.                                                          thePosnRect.bottom-thePosnRect.top,
  1149.                                                          true);
  1150.                                     ResizeWindow(theDocument);
  1151.                                 }
  1152.                             break;
  1153.  
  1154.             case pPosition:
  1155.                             err = GetPointFromDescriptor(dataDesc, &thePosn);
  1156.                             /* the point is for the structure region, and is in global coordinates */
  1157.                             /* MoveWindow applies to the content region, so we have to massage a little */
  1158.                             
  1159.                             hOffset = (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.left -
  1160.                                                 (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.left;
  1161.                                                 
  1162.                             vOffset = (**((WindowPeek)theWindowPropToken.tokenWindowToken)->contRgn).rgnBBox.top -
  1163.                                                 (**((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn).rgnBBox.top;
  1164.                                                 
  1165.                                                 
  1166.                             thePosn.v  += vOffset;
  1167.                             thePosn.h  += hOffset;
  1168.                             
  1169.                             MoveWindow(theWindowPropToken.tokenWindowToken,
  1170.                                                  thePosn.h,
  1171.                                                  thePosn.v,
  1172.                                                  false);
  1173.                                                  
  1174.                             ResizeWindow(theDocument);
  1175.                             break;
  1176.             
  1177.           case pIsZoomed:
  1178.                             err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1179.                             if (theBoolean)
  1180.                                 ZoomWindow(qd.thePort,
  1181.                                                      inZoomOut,
  1182.                                                      false);
  1183.                             else
  1184.                                 ZoomWindow(qd.thePort,
  1185.                                                      inZoomIn,
  1186.                                                      false);
  1187.                                                                     
  1188.                             ResizeWindow(theDocument);
  1189.                             break;
  1190.             
  1191.             case pVisible:
  1192.                             err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1193.                             if (theBoolean)
  1194.                                 ShowWindow(theWindowPropToken.tokenWindowToken);
  1195.                             else
  1196.                                 HideWindow(theWindowPropToken.tokenWindowToken);
  1197.                             break;
  1198.             
  1199.             case pPageSetup:
  1200.                             err = GetTHPrintFromDescriptor(dataDesc, &theTHPrint);
  1201.                                 
  1202.                             if (theTHPrint) 
  1203.                                 {
  1204.                                     if (theDocument->thePrintSetup) 
  1205.                                         DisposHandle((Handle)theDocument->thePrintSetup);
  1206.                                         
  1207.                                     theDocument->thePrintSetup = theTHPrint;
  1208.                                     theDocument->dirty = true;
  1209.                                     ResizePageSetupForDocument(theDocument);
  1210.                                 }
  1211.                             break;
  1212.                             
  1213.             case pShowBorders:
  1214.                             err = GetBooleanFromDescriptor(dataDesc, &theBoolean);
  1215.                             theDocument->showBorders = theBoolean;
  1216.                             if (theBoolean)
  1217.                                 DrawPageExtras(theDocument); /* Does the clipping as well as drawing borders/page breaks */
  1218.                             else
  1219.                                 InvalidateDocument(theDocument);
  1220.                             break;
  1221.                             
  1222.             case pSelection:
  1223.                             err = AECoerceDesc(dataDesc, typeMyText, &tokenDesc);
  1224.                             
  1225.                             GetRawDataFromDescriptor(&tokenDesc,
  1226.                                                                              (Ptr)&myTextToken,
  1227.                                                                              sizeof(myTextToken),
  1228.                                                                              &tokenSize);
  1229.                                                                                              
  1230.                             ignoreErr = AEDisposeDesc(&tokenDesc);
  1231.                             
  1232.                             if (err == noErr) 
  1233.                                 {
  1234.                                     /* got a text token */
  1235.                                     
  1236.                                     theDocument = DPtrFromWindowPtr(myTextToken.tokenWindow);
  1237.                                     theHTE      = theDocument->theText;
  1238.                                     
  1239.                                     TESetSelect(myTextToken.tokenOffset-1,
  1240.                                                             myTextToken.tokenOffset+myTextToken.tokenLength-1,
  1241.                                                             theHTE);
  1242.                                 }
  1243.                             break;
  1244.             
  1245.             case pIndex:
  1246.             case pIsModal:
  1247.             case pIsResizable:
  1248.             case pHasTitleBar:
  1249.             case pHasCloseBox:
  1250.             case pIsFloating:
  1251.             case pBestType:
  1252.             case pClass:
  1253.             case pDefaultType:
  1254.             case pIsZoomable:
  1255.             case pIsModified:
  1256.             default:
  1257.                             err = errAEEventNotHandled; /* We don't allow these to be set or we don't understand it*/
  1258.         }
  1259.         
  1260.         SetPort(oldPort);
  1261.         
  1262.         return(err);
  1263.                 
  1264.     } /* SetWindowProperty */
  1265.     
  1266. /* -----------------------------------------------------------------------
  1267.         Name:             AddDescStyleItem
  1268.         Purpose:        Adds the kAEXXXX style to theStyle.
  1269.      -----------------------------------------------------------------------**/
  1270.      
  1271. pascal void AddDescStyleItem(DescType theDesc, Style *theStyle)
  1272.     {
  1273.         if (theDesc == kAEBold)
  1274.             *theStyle = *theStyle+bold;
  1275.         else
  1276.         if (theDesc == kAEItalic)
  1277.             *theStyle = *theStyle+italic;
  1278.         else
  1279.         if (theDesc == kAEUnderline)
  1280.             *theStyle = *theStyle+underline;
  1281.         else
  1282.         if (theDesc == kAEOutline)
  1283.             *theStyle = *theStyle+outline;
  1284.         else
  1285.         if (theDesc == kAEShadow)
  1286.             *theStyle = *theStyle+shadow;
  1287.         else
  1288.         if (theDesc == kAECondensed)
  1289.             *theStyle = *theStyle+condense;
  1290.         else
  1291.         if (theDesc == kAEExpanded)
  1292.             *theStyle = *theStyle+extend;
  1293.         else
  1294.         if (theDesc == kAEPlain)
  1295.             *theStyle = 0;
  1296.     } /* AddDescStyleItem */
  1297.     
  1298. pascal OSErr MakeStyleFromAEList(const AEDescList *styleList, Style *theStyle, Boolean *hadPlain)
  1299.     {
  1300.         OSErr     myErr;
  1301.         DescType  styleDesc;
  1302.         long      itemsInList;
  1303.         long      actSize;
  1304.         AEKeyword keywd;
  1305.         DescType  typeCode;
  1306.             
  1307.         *hadPlain = false;
  1308.         *theStyle = 0;
  1309.         
  1310.       myErr = AECountItems(styleList, &itemsInList);
  1311.         while (itemsInList>0)
  1312.           if (myErr==noErr)
  1313.                 {
  1314.                     myErr  = AEGetNthPtr(styleList,
  1315.                                                              itemsInList,
  1316.                                                              typeEnumerated,
  1317.                                                              &keywd,
  1318.                                                              &typeCode,
  1319.                                                              (Ptr)&styleDesc,
  1320.                                                              sizeof(styleDesc),
  1321.                                                              &actSize);
  1322.                     
  1323.                     AddDescStyleItem(styleDesc, theStyle);
  1324.                     
  1325.                     if (styleDesc == kAEPlain) 
  1326.                       {
  1327.                             itemsInList = 0;
  1328.                             *hadPlain    = true;
  1329.                         }
  1330.                     else
  1331.                       itemsInList--;
  1332.                 }
  1333.                 
  1334.         return(myErr);
  1335.     } /*MakeStyleFromAEList*/
  1336.     
  1337. pascal OSErr GetTextStyles(const AEDesc *dataDesc, Style *onStyles, Style *offStyles)
  1338.     {
  1339.         OSErr      myErr;
  1340.         OSErr      ignoreErr;
  1341.         AEDescList textSDesc;
  1342.         AEDescList onDesc;
  1343.         AEDescList offDesc;
  1344.         Boolean    hadPlain;
  1345.             
  1346.       textSDesc.dataHandle = nil;
  1347.       onDesc.dataHandle    = nil;
  1348.       offDesc.dataHandle   = nil;
  1349.         
  1350.         *onStyles  = 0;
  1351.         *offStyles = 0;
  1352.         
  1353.       myErr = AECoerceDesc(dataDesc, typeAERecord, &textSDesc);
  1354.         
  1355.         if (myErr==noErr)
  1356.           myErr = AEGetKeyDesc(&textSDesc, keyAEOnStyles, typeAEList, &onDesc);
  1357.         
  1358.         if (myErr==noErr)
  1359.           myErr = AEGetKeyDesc(&textSDesc, keyAEOffStyles, typeAEList, &offDesc);
  1360.         
  1361.         if (myErr==noErr)
  1362.             myErr = MakeStyleFromAEList(&onDesc,  onStyles, &hadPlain);
  1363.             
  1364.         if (hadPlain)
  1365.             *offStyles = bold+italic+underline+outline+shadow+condense+extend;
  1366.         else
  1367.             {
  1368.                 if (myErr==noErr)
  1369.                     myErr = MakeStyleFromAEList(&offDesc, offStyles, &hadPlain);
  1370.         
  1371.                 if (hadPlain)
  1372.                     myErr = errAEEventFailed;
  1373.             }
  1374.             
  1375.         if (textSDesc.dataHandle)
  1376.             ignoreErr = AEDisposeDesc(&textSDesc);
  1377.             
  1378.         if (onDesc.dataHandle)
  1379.             ignoreErr = AEDisposeDesc(&onDesc);
  1380.             
  1381.         if (offDesc.dataHandle)
  1382.             ignoreErr = AEDisposeDesc(&offDesc);
  1383.         
  1384.         return(myErr);
  1385.     } /* GetTextStyles */
  1386.  
  1387. /* -----------------------------------------------------------------------
  1388.         Name:             SetTextProperty
  1389.         Purpose:        Sets the text property specfied by theTextPropToken to
  1390.                                 that in dataDesc.
  1391.      -----------------------------------------------------------------------**/
  1392.      
  1393. pascal OSErr SetTextProperty(const AEDesc *tokenDesc, const AEDesc *dataDesc)
  1394.     {
  1395.       TEHandle      theHTE;
  1396.         DPtr          theDoc;
  1397.         Str255        name;
  1398.         short         theSize;
  1399.         OSErr         myErr;
  1400.         OSErr         ignoreErr;
  1401.         Style         onStyle;
  1402.         Style         offStyle;
  1403.         textPropToken theTextPropToken;
  1404.         AEDesc        newDesc;
  1405.         Size          tokenSize;
  1406.         
  1407.       newDesc.dataHandle = nil;
  1408.         
  1409.       myErr = AECoerceDesc(tokenDesc, typeMyTextProp, &newDesc);
  1410.         if (myErr == noErr)
  1411.             {
  1412.                 GetRawDataFromDescriptor(&newDesc,
  1413.                                                                  (Ptr)&theTextPropToken,
  1414.                                                                  sizeof(theTextPropToken),
  1415.                                                                  &tokenSize);
  1416.                 ignoreErr = AEDisposeDesc(&newDesc);
  1417.             }
  1418.         else
  1419.             return(myErr);
  1420.             
  1421.         theDoc = DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1422.         theDoc->dirty = true;
  1423.         
  1424.         switch (theTextPropToken.propertyProperty) {
  1425.         
  1426.             case pContents:
  1427.                         theHTE = theDoc->theText;
  1428.                                     TESetSelect(theTextPropToken.propertyTextToken.tokenOffset-1,
  1429.                                                             theTextPropToken.propertyTextToken.tokenOffset+
  1430.                                                                                     theTextPropToken.propertyTextToken.tokenLength-1,
  1431.                                                             theHTE);
  1432.                                     
  1433.                                     if (OKToModifySelection(theDoc))
  1434.                                         {
  1435.                                             DoTEDeleteSectionRecalc(theDoc);
  1436.                                             TEDelete(theHTE);
  1437.                                             myErr = GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1438.                                             RecalcChangedSectionBorders(theDoc);
  1439.                                         }
  1440.                                     else
  1441.                                         myErr = errCantWriteSubscriber;
  1442.                                         
  1443.                                     break;
  1444.             
  1445.             case pFont: myErr = GetPStringFromDescriptor(dataDesc, (char *)name);
  1446.                                     
  1447.                                     if (myErr==noErr)
  1448.                                         myErr = SetTheFontOfTheTokenText(theTextPropToken.propertyTextToken,
  1449.                                                                                                          name);
  1450.                                     break;
  1451.             
  1452.           case pPointSize:
  1453.                         myErr = GetIntegerFromDescriptor(dataDesc, &theSize);
  1454.                                     if (myErr==noErr)
  1455.                                         myErr = SetTheSizeOfTheTokenText(theTextPropToken.propertyTextToken,
  1456.                                                                                                           theSize);
  1457.                                     break;
  1458.                                     
  1459.             case pTextStyles:
  1460.                                     onStyle  = 0;
  1461.                                     offStyle = 0;
  1462.                                     
  1463.                                     myErr = GetTextStyles(dataDesc, &onStyle, &offStyle);
  1464.                     
  1465.                                     if (myErr==noErr)
  1466.                                         if (onStyle & offStyle != 0)
  1467.                                             myErr = errAEEventFailed;
  1468.                                         else
  1469.                                             myErr = SetTheStyleOfTheTokenText(&theTextPropToken.propertyTextToken,
  1470.                                                                                                                 onStyle,
  1471.                                                                                                                 offStyle);
  1472.                                     break;
  1473.                                     
  1474.             default: myErr = errAEWrongDataType;
  1475.             
  1476.         }
  1477.                         
  1478.         return(myErr);
  1479.             
  1480.     } /* SetTextProperty */
  1481.     
  1482. /* -----------------------------------------------------------------------
  1483.         Name:             HandleSetData
  1484.         Purpose:        Resolves the object into a token (could be one of many) and
  1485.                                 the sets the data of that object to dataDesc.
  1486.      -----------------------------------------------------------------------**/
  1487.      
  1488. pascal OSErr HandleSetData(const AEDesc *theObj, const AEDesc *dataDesc, AppleEvent *reply)
  1489. {
  1490.   OSErr           myErr;
  1491.   OSErr           ignoreErr;
  1492.     AEDesc          newDesc;
  1493.     DPtr            theDocument;
  1494.     TEHandle        theHTE;
  1495.     TextToken       theTextToken;
  1496.     Size            tokenSize;
  1497.     AEDesc          objTokenDesc;
  1498.     
  1499.     objTokenDesc.dataHandle = nil;
  1500.     newDesc.dataHandle      = nil;
  1501.     
  1502.     /*
  1503.         Coerce theObj into a token which we can use - 
  1504.              set the property or data for that token
  1505.     */
  1506.     
  1507.     myErr = AEResolve(theObj ,kAEIDoMinimum, &objTokenDesc);
  1508.         
  1509.     /* We don't actually allow ANY app property setting, but
  1510.        just incase we'll decode looking for an typeMyApplProp and flag an error -
  1511.          do same for menu related tokens
  1512.     */
  1513.     
  1514.     switch (objTokenDesc.descriptorType) {
  1515.         case typeMyWindowProp: myErr = SetWindowProperty(&objTokenDesc, dataDesc);
  1516.                                                      break;
  1517.         
  1518.         case typeMyTextProp :  myErr = SetTextProperty(&objTokenDesc, dataDesc);
  1519.                                break;
  1520.  
  1521.         case typeMyText:        if (AECoerceDesc(&objTokenDesc, typeMyText, &newDesc) == noErr) 
  1522.                                                         {
  1523.                                                             GetRawDataFromDescriptor(&newDesc,
  1524.                                                                                                              (Ptr)&theTextToken,
  1525.                                                                                                              sizeof(theTextToken),
  1526.                                                                                                              &tokenSize);
  1527.                                                                                                              
  1528.                                                             ignoreErr = AEDisposeDesc(&newDesc);
  1529.                                                                                                              
  1530.                                                             theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  1531.                                                             theHTE            = theDocument->theText;
  1532.                                                             
  1533.                                                             TESetSelect(theTextToken.tokenOffset-1,
  1534.                                                                                     theTextToken.tokenOffset+
  1535.                                                                                                             theTextToken.tokenLength-1,
  1536.                                                                                     theHTE);
  1537.                                                             
  1538.                                                             if (OKToModifySelection(theDocument))
  1539.                                                                 {
  1540.                                                                     DoTEDeleteSectionRecalc(theDocument);
  1541.                                                                     TEDelete(theHTE);
  1542.                                                                         
  1543.                                                                     myErr = GetStyledTextFromDescIntoTEHandle(dataDesc, theHTE);
  1544.                                                                     RecalcChangedSectionBorders(theDocument);
  1545.                                                                 }
  1546.                                                             else
  1547.                                                                 myErr = errCantWriteSubscriber;
  1548.                                                                 
  1549.                                                             theDocument->dirty = true;
  1550.                                                         }
  1551.                                                     break;
  1552.                                                     
  1553.         // Read only items and properties and those we don't know
  1554.         case typeMyApplProp:
  1555.         case typeMyMenu:
  1556.         case typeMyMenuProp:
  1557.         case typeMyMenuItem:
  1558.         case typeMyItemProp:                                                        
  1559.         default:            myErr = errAEWrongDataType;
  1560.     }
  1561.     
  1562.     if (objTokenDesc.dataHandle)
  1563.         ignoreErr = AEDisposeDesc(&objTokenDesc);
  1564.     
  1565.     if (myErr == errCantWriteSubscriber)
  1566.         AddErrorTextToReply("\pCannot write into subscriber", reply);
  1567.         
  1568.     return(myErr);
  1569. }    /* HandleSetData */
  1570.  
  1571. /*
  1572.     A few convenient FORWARDS...
  1573. */
  1574.  
  1575. pascal OSErr MakeWindowObj( WindowPtr theWindow, AEDesc *dMyDoc);
  1576. pascal OSErr MakeTextObj(WindowPtr theWindow,
  1577.                                                  short     selStart,
  1578.                                                  short     selEnd,
  1579.                                                  AEDesc    *selTextObj);
  1580.  
  1581. pascal OSErr MakeMenuObj(Str255 theName, AEDesc *resultingObj);
  1582. pascal OSErr MakeMenuItemObj(Str255 theName, short theItem, AEDesc *resultingObj);
  1583. pascal OSErr MakeClassObj(DescType theClass, AEDesc *myClassObj);
  1584. /*
  1585.     Back to real code
  1586. */
  1587. pascal OSErr MakeSelTextObj( WindowPtr theWindow,
  1588.                                                          TEHandle  theTextEditHandle,
  1589.                                                          AEDesc    *selTextObj)
  1590. /*
  1591.     This is a hack to get the AppleScript Alpha to work...
  1592. */
  1593.     {
  1594.         OSErr    myErr;
  1595.         OSErr    ignoreErr;
  1596.         AEDesc   dNull;
  1597.         AEDesc   dMyDoc;
  1598.         AEDesc   startOfs;
  1599.         AEDesc   endOfs;
  1600.         AEDesc   startObj;
  1601.         AEDesc   endObj;
  1602.         AEDesc   rangeDesc;
  1603.         long     startChar;
  1604.         long     endChar;
  1605.         Boolean  spotFlag;
  1606.             
  1607.         myErr = noErr;
  1608.         
  1609.         if (theWindow==nil) 
  1610.             return(noErr);
  1611.             
  1612.         selTextObj->dataHandle = nil;
  1613.         dMyDoc.dataHandle      = nil;
  1614.         startObj.dataHandle    = nil;
  1615.         endObj.dataHandle      = nil;
  1616.         
  1617.         /* 
  1618.             make the window object 
  1619.         */
  1620.         
  1621.         myErr = MakeWindowObj(theWindow, &dMyDoc);
  1622.             
  1623.         if (myErr==noErr)
  1624.             {
  1625.                 /* get the start and end of selection */
  1626.                 
  1627.                 startChar = (*theTextEditHandle)->selStart+1;    /* start counting obj's from 1, not 0 */
  1628.                 endChar   = (*theTextEditHandle)->selEnd;
  1629.                 spotFlag  = ((*theTextEditHandle)->selStart == (*theTextEditHandle)->selEnd);
  1630.                     
  1631.                 myErr = CreateOffsetDescriptor(startChar, &startOfs);
  1632.                             
  1633.                 if (myErr==noErr)
  1634.                     if (spotFlag)
  1635.                         myErr = CreateObjSpecifier(cSpot,
  1636.                                                                              &dMyDoc,
  1637.                                                                              formAbsolutePosition, 
  1638.                                                                              &startOfs, 
  1639.                                                                              true, 
  1640.                                                                              selTextObj);
  1641.                     else
  1642.                         {
  1643.                             /* not a spot - must represent as range */
  1644.                             /* make obj for start char */
  1645.                             
  1646.                             myErr = AECreateDesc(typeNull, nil , 0, &dNull);
  1647.                             
  1648.                             myErr = CreateObjSpecifier(cChar,
  1649.                                                        &dNull,
  1650.                                                                                  formAbsolutePosition,
  1651.                                                                                  &startOfs,
  1652.                                                                                  false,
  1653.                                                                                  &startObj);
  1654.                             
  1655.                             if (myErr==noErr) 
  1656.                                 myErr = CreateOffsetDescriptor(endChar, &endOfs);
  1657.                             
  1658.                             if (myErr==noErr) 
  1659.                                 myErr = CreateObjSpecifier(cChar,
  1660.                                                                                      &dNull,
  1661.                                                                                      formAbsolutePosition,
  1662.                                                                                      &endOfs,
  1663.                                                                                      false,
  1664.                                                                                      &endObj);
  1665.                             
  1666.                             if (myErr==noErr) 
  1667.                                 myErr = CreateRangeDescriptor(&startObj,
  1668.                                                                                             &endObj,
  1669.                                                                                             false,
  1670.                                                                                             &rangeDesc);
  1671.                             
  1672.                             if (myErr==noErr) 
  1673.                                 myErr = CreateObjSpecifier(cChar,
  1674.                                                                                      &dMyDoc,
  1675.                                                                                      formRange,
  1676.                                                                                      &rangeDesc,
  1677.                                                                                      true,
  1678.                                                                                      selTextObj);
  1679.                                                                                      
  1680.                             if (startObj.dataHandle)
  1681.                               ignoreErr = AEDisposeDesc(&startObj);
  1682.                                 
  1683.                             if (startOfs.dataHandle)
  1684.                               ignoreErr = AEDisposeDesc(&startOfs);
  1685.                                 
  1686.                             if (endObj.dataHandle)
  1687.                               ignoreErr = AEDisposeDesc(&endObj);
  1688.                                 
  1689.                             if (endOfs.dataHandle)
  1690.                               ignoreErr = AEDisposeDesc(&endOfs);
  1691.                         }
  1692.             }
  1693.             
  1694.         return(myErr);
  1695.     }    /* MakeSelTextObj */
  1696.  
  1697. /* -----------------------------------------------------------------------
  1698.         Name:             DoSetData
  1699.         Purpose:        Handles the SetData Apple Event, extracting the direct
  1700.                                 object (which says what to set) and the data (what to set
  1701.                                 it to).
  1702.      -----------------------------------------------------------------------**/
  1703.      
  1704. pascal OSErr DoSetData(const AppleEvent *theAppleEvent,
  1705.                                                AppleEvent *reply,
  1706.                                                          long        handlerRefCon)
  1707.   {
  1708. #pragma unused (reply, handlerRefCon)
  1709.     
  1710.         OSErr  myErr;
  1711.         OSErr  ignoreErr;
  1712.         AEDesc myDirObj;
  1713.         AEDesc myDataDesc;
  1714.         
  1715.         myDataDesc.dataHandle = nil;
  1716.         myDirObj.dataHandle   = nil;
  1717.                 
  1718.         /* pick up the direct object, which is the object whose data is to be set */
  1719.         
  1720.         myErr = AEGetParamDesc(theAppleEvent,
  1721.                                                      keyDirectObject,
  1722.                                                      typeWildCard,
  1723.                                                      &myDirObj);
  1724.             
  1725.         /* now the data to set it to - typeWildCard means get as is*/
  1726.         if (myErr == noErr) 
  1727.             myErr = AEGetParamDesc( theAppleEvent,
  1728.                                                             keyAEData,
  1729.                                                             typeWildCard,
  1730.                                                             &myDataDesc);
  1731.         
  1732.         /* missing any parameters? */
  1733.         if (myErr == noErr) 
  1734.             myErr = GotRequiredParams(theAppleEvent);
  1735.         
  1736.         /* set the data */
  1737.         if (myErr == noErr) 
  1738.             myErr = HandleSetData(&myDirObj, &myDataDesc, reply);
  1739.             
  1740.         if (myDataDesc.dataHandle)
  1741.             ignoreErr = AEDisposeDesc(&myDataDesc);
  1742.             
  1743.         if (myDirObj.dataHandle)
  1744.             ignoreErr = AEDisposeDesc(&myDirObj);
  1745.   
  1746.         return(myErr);
  1747.     }    /* DoSetData */
  1748.     
  1749. pascal void StyleTokConst(short theStyleItem, DescType *thekConst)
  1750.     {
  1751.         switch (theStyleItem) {
  1752.           case bold      : *thekConst = kAEBold;
  1753.                                              break;
  1754.       case italic    : *thekConst = kAEItalic;
  1755.                                              break;
  1756.       case underline : *thekConst = kAEUnderline;
  1757.                                              break;
  1758.       case outline   : *thekConst = kAEOutline;
  1759.                                              break;
  1760.             case shadow    : *thekConst = kAEShadow;
  1761.                                              break;
  1762.             case condense  : *thekConst = kAECondensed;
  1763.                                              break;
  1764.             case extend    : *thekConst = kAEExpanded;
  1765.                                              break;
  1766.         }
  1767.     } /*StyleTokConst*/
  1768.     
  1769. pascal OSErr BuildTypeTextStylesDesc(Style onStyles, Style offStyles, AEDesc *resultDesc)
  1770.     {
  1771.  
  1772.         OSErr     myErr;
  1773.         OSErr     ignoreErr;
  1774.         short     myStyleItem;
  1775.         DescType  styleConst;
  1776.         AEDesc    onStylesDesc;
  1777.         AEDesc    offStylesDesc;
  1778.         AEDesc    dataDesc;
  1779.         
  1780.         onStylesDesc.dataHandle  = nil;
  1781.         offStylesDesc.dataHandle = nil;
  1782.         dataDesc.dataHandle  = nil;
  1783.     
  1784.         myErr = AECreateList(nil, 0, true,  &dataDesc);
  1785.         
  1786.         myErr = AECreateList(nil, 0, false, &onStylesDesc);
  1787.         myErr = AECreateList(nil, 0, false, &offStylesDesc);
  1788.         
  1789.         for (myStyleItem = bold; myStyleItem<=extend; myStyleItem = myStyleItem <<1)
  1790.             if (myErr==noErr)
  1791.                 {
  1792.                     StyleTokConst(myStyleItem, &styleConst);
  1793.                     if (myStyleItem & onStyles)
  1794.                         myErr  = AEPutPtr(&onStylesDesc,
  1795.                                                             0,                /*add to end of list*/
  1796.                                                             typeEnumerated, /* text for style name */
  1797.                                                             (Ptr)&styleConst,
  1798.                                                             sizeof(styleConst));
  1799.                     
  1800.                     if (myStyleItem & offStyles)
  1801.                         myErr  = AEPutPtr(&offStylesDesc,
  1802.                                                             0,                /*add to end of list*/
  1803.                                                             typeEnumerated, /* text for style name */
  1804.                                                             (Ptr)&styleConst,
  1805.                                                             sizeof(styleConst));
  1806.             }
  1807.         
  1808.         if (myErr==noErr)
  1809.             myErr = AEPutKeyDesc(&dataDesc, keyAEOnStyles,  &onStylesDesc);
  1810.         
  1811.         if (myErr==noErr)
  1812.             myErr = AEPutKeyDesc(&dataDesc, keyAEOffStyles, &offStylesDesc);
  1813.         
  1814.         if (myErr==noErr)
  1815.             myErr = AECoerceDesc(&dataDesc, typeTextStyles, resultDesc);
  1816.             
  1817.         if (onStylesDesc.dataHandle)
  1818.             ignoreErr = AEDisposeDesc(&onStylesDesc);
  1819.             
  1820.         if (offStylesDesc.dataHandle)
  1821.             ignoreErr = AEDisposeDesc(&offStylesDesc);
  1822.             
  1823.         if (dataDesc.dataHandle)
  1824.             ignoreErr = AEDisposeDesc(&dataDesc);
  1825.     
  1826.         return(myErr);
  1827.     }
  1828.  
  1829. pascal OSErr BuildTextStylesDesc(Style theStyle, AEDesc *resultDesc)
  1830.     {
  1831.         short     myStyleItem;
  1832.         Style     onStyles;
  1833.         Style     offStyles;
  1834.                 
  1835.         onStyles  = 0;
  1836.         offStyles = 0;
  1837.         
  1838.         for (myStyleItem = bold; myStyleItem<=extend; myStyleItem = myStyleItem <<1)
  1839.             {
  1840.                 if (myStyleItem & theStyle)
  1841.                     onStyles  = onStyles  + myStyleItem;
  1842.                 else
  1843.                     offStyles = offStyles + myStyleItem;
  1844.             }
  1845.     
  1846.         return(BuildTypeTextStylesDesc(onStyles, offStyles, resultDesc));
  1847.         
  1848.     } /* BuildTextStylesDesc */
  1849.         
  1850. pascal OSErr BuildStyledTextDesc(TEHandle theHTE, short start, short howLong, AEDesc *resultDesc)
  1851.     {
  1852.         AEDesc       listDesc;
  1853.         short        oldSelStart;
  1854.         short        oldSelEnd;
  1855.         StScrpHandle myStScrpHandle;
  1856.         OSErr        myErr;
  1857.         OSErr        ignoreErr;
  1858.         
  1859.         listDesc.dataHandle = nil;
  1860.         
  1861.         oldSelStart = (**theHTE).selStart;
  1862.         oldSelEnd   = (**theHTE).selEnd;
  1863.         
  1864.         TESetSelect(start-1, start+howLong-2, theHTE);
  1865.         
  1866.         myErr = AECreateList(nil, 0, true,  &listDesc);
  1867.         
  1868.         HLock((Handle)(**theHTE).hText);
  1869.                                                          
  1870.         if (myErr==noErr)
  1871.             myErr = AEPutKeyPtr(&listDesc,
  1872.                                 keyAEText,
  1873.                                                     typeChar,
  1874.                                                     (Ptr)&(*(**theHTE).hText)[start-1],
  1875.                                                     howLong);
  1876.                                                     
  1877.         HUnlock((Handle)(**theHTE).hText);
  1878.         
  1879.         myStScrpHandle = GetStylScrap(theHTE);
  1880.         
  1881.         if (myStScrpHandle)
  1882.             {
  1883.                 HLock((Handle)myStScrpHandle);
  1884.                 
  1885.                 if (myErr==noErr)
  1886.                     myErr = AEPutKeyPtr(&listDesc,
  1887.                                         keyAEStyles,
  1888.                                                             typeScrapStyles,
  1889.                                                             (Ptr)*myStScrpHandle,
  1890.                                                             GetHandleSize((Handle)myStScrpHandle));
  1891.                     
  1892.                 HUnlock((Handle)myStScrpHandle);
  1893.             }    
  1894.         else
  1895.             myErr = AEPutKeyPtr(&listDesc,
  1896.                                                     keyAEStyles,
  1897.                                                     typeScrapStyles,
  1898.                                                     (Ptr)nil,
  1899.                                                     0);
  1900.         
  1901.         if (myErr==noErr)
  1902.             myErr = AECoerceDesc(&listDesc, typeStyledText, resultDesc); // should be typeIntlText
  1903.         
  1904.         if (listDesc.dataHandle)
  1905.             ignoreErr = AEDisposeDesc(&listDesc);
  1906.         
  1907.         TESetSelect(oldSelStart, oldSelEnd, theHTE);
  1908.         
  1909.         return(myErr);
  1910.     }
  1911.     
  1912. /* -----------------------------------------------------------------------
  1913.         Name:             GetTextProperty
  1914.         Purpose:        Fills dataDesc with the requested text property.
  1915.      -----------------------------------------------------------------------**/
  1916.      
  1917. pascal OSErr GetTextProperty(const AEDesc *theTokenDesc, AEDesc *dataDesc)
  1918.     {
  1919.       DPtr          theDocument;
  1920.         TEHandle      theHTE;
  1921.         Str255        fontName;
  1922.         short         theSize;
  1923.         GrafPtr       oldPort;
  1924.         TextStyle     theTextStyle;
  1925.         short         lineHeight;
  1926.         short         fontAscent;
  1927.         textPropToken theTextPropToken;
  1928.         OSErr         myErr;
  1929.         OSErr                    ignoreErr;
  1930.         Size          tokenSize;
  1931.         AEDesc        newDesc;
  1932.         
  1933.       myErr = AECoerceDesc(theTokenDesc, typeMyTextProp, &newDesc);
  1934.         if (myErr == noErr)
  1935.             {
  1936.                 GetRawDataFromDescriptor(&newDesc,
  1937.                                                                  (Ptr)&theTextPropToken,
  1938.                                                                  sizeof(theTextPropToken),
  1939.                                                                  &tokenSize);
  1940.                 ignoreErr= AEDisposeDesc(&newDesc);                                                 
  1941.             }
  1942.         else
  1943.           return(myErr);
  1944.  
  1945.         /*
  1946.             For each property we build a descriptor to be returned as the reply.
  1947.         */
  1948.                 
  1949.         theDocument = DPtrFromWindowPtr(theTextPropToken.propertyTextToken.tokenWindow);
  1950.         theHTE             = theDocument->theText;
  1951.         
  1952.         TEGetStyle (theTextPropToken.propertyTextToken.tokenOffset-1,
  1953.                                 &theTextStyle,
  1954.                                 &lineHeight,
  1955.                                 &fontAscent,
  1956.                                 theHTE);
  1957.                                         
  1958.         switch (theTextPropToken.propertyProperty){ 
  1959.  
  1960.             case pContents:
  1961.             
  1962.                     myErr = BuildStyledTextDesc(theHTE,
  1963.                                                                             theTextPropToken.propertyTextToken.tokenOffset,
  1964.                                                                             theTextPropToken.propertyTextToken.tokenLength,
  1965.                                                                             dataDesc);
  1966.                     break;
  1967.             
  1968.             case pFont:
  1969.             
  1970.                     GetFontName(theTextStyle.tsFont, fontName);
  1971.                     
  1972.                     myErr = AECreateDesc(typeChar,
  1973.                                                              (Ptr)&fontName[1],
  1974.                                                              fontName[0],
  1975.                                                              dataDesc);
  1976.                     break;
  1977.                     
  1978.             case pTextStyles:
  1979.             
  1980.                     myErr = BuildTextStylesDesc(theTextStyle.tsFace, dataDesc);
  1981.                     break;
  1982.  
  1983.             case pPointSize:
  1984.  
  1985.                     myErr =CreateOffsetDescriptor(theTextStyle.tsSize, dataDesc);
  1986.                     break;
  1987.                     
  1988.             case pScriptTag:
  1989.                     
  1990.                     myErr = CreateOffsetDescriptor(smSystemScript, dataDesc);
  1991.                     break;
  1992.             
  1993.             case pStringWidth:
  1994.                 
  1995.                     GetPort(&oldPort);
  1996.                     SetPort(theTextPropToken.propertyTextToken.tokenWindow);
  1997.                     
  1998.                     HLock((Handle)(**theHTE).hText);
  1999.                     theSize = TextWidth(&(**theHTE).hText,
  2000.                                                             theTextPropToken.propertyTextToken.tokenOffset-1,
  2001.                                                             theTextPropToken.propertyTextToken.tokenLength);
  2002.                     
  2003.                     HUnlock((Handle)(**theHTE).hText);
  2004.                     
  2005.                     SetPort(oldPort);
  2006.                     myErr = CreateOffsetDescriptor(theSize, dataDesc);
  2007.                     
  2008.                     break;
  2009.             
  2010.             case pColor:
  2011.             
  2012.                     myErr = AECreateDesc(typeRGBColor,
  2013.                                                              (Ptr)&theTextStyle.tsColor,
  2014.                                                              sizeof(theTextStyle.tsColor),
  2015.                                                              dataDesc);
  2016.                     break;
  2017.  
  2018.             case pDefaultType:
  2019.             case pBestType:
  2020.             
  2021.                     myErr = MakeTextObj(theTextPropToken.propertyTextToken.tokenWindow,
  2022.                                                          theTextPropToken.propertyTextToken.tokenOffset-1,
  2023.                                                          theTextPropToken.propertyTextToken.tokenOffset+
  2024.                                                          theTextPropToken.propertyTextToken.tokenLength-1,
  2025.                                                          dataDesc);
  2026.                     break;
  2027.  
  2028.             case pClass:
  2029.             
  2030.                     myErr = MakeClassObj(cChar, dataDesc);
  2031.                     break;
  2032.                     
  2033.             default:
  2034.                     myErr = errAEEventNotHandled;
  2035.         }
  2036.         return(myErr);
  2037.         
  2038.     } /*GetTextProperty*/
  2039.     
  2040. /* -----------------------------------------------------------------------
  2041.         Name:             GetWindowProperty
  2042.         Purpose:        Fills dataDesc with the requested window property.
  2043.      -----------------------------------------------------------------------**/
  2044. typedef Rect **RectHandle;
  2045.  
  2046. pascal OSErr GetWindowProperty(const AEDesc *theWPTokenObj, AEDesc *dataDesc)
  2047.   {             
  2048.     OSErr           theErr;
  2049.         OSErr           ignoreErr;
  2050.         Str255          theName;
  2051.         Boolean         theBoolean;
  2052.         Rect            theRect;
  2053.         Point           thePoint;
  2054.         Rect            winRect;
  2055.         Rect            userRect;
  2056.         short           theIndex;
  2057.         DPtr            theDocument;
  2058.         TEHandle        theHTE;
  2059.         windowPropToken theWindowPropToken;
  2060.         AEDesc          newDesc;
  2061.         Size            tokenSize;
  2062.         
  2063.       theErr = AECoerceDesc(theWPTokenObj,typeMyWindowProp, &newDesc);
  2064.         
  2065.         if (theErr == noErr)
  2066.             {
  2067.                 GetRawDataFromDescriptor(&newDesc,
  2068.                                                                  (Ptr)&theWindowPropToken,
  2069.                                                                  sizeof(theWindowPropToken),
  2070.                                                                  &tokenSize);
  2071.                                                                  
  2072.                 ignoreErr = AEDisposeDesc(&newDesc);
  2073.             }
  2074.         else
  2075.           return(theErr);
  2076.             
  2077.         switch (theWindowPropToken.tokenProperty) { 
  2078.             
  2079.             case pName:
  2080.             
  2081.                 GetWTitle(theWindowPropToken.tokenWindowToken, theName);
  2082.                 theErr = AECreateDesc(typeChar,
  2083.                                                             (Ptr)&theName[1],
  2084.                                                             theName[0],
  2085.                                                             dataDesc);
  2086.                 break;
  2087.             
  2088.             case pContents:
  2089.             
  2090.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2091.                 theHTE      = theDocument->theText;
  2092.                 
  2093.                 theErr = BuildStyledTextDesc( theHTE,
  2094.                                                                             1,
  2095.                                                                             (**theHTE).teLength,
  2096.                                                                             dataDesc);
  2097.                 break;
  2098.             
  2099.             case pBounds:
  2100.             
  2101.                 SetPort(theWindowPropToken.tokenWindowToken);
  2102.  
  2103.                 theRect = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox;
  2104.                 
  2105.                 theErr  = AECreateDesc(typeQDRectangle,
  2106.                                                              (Ptr)&theRect,
  2107.                                                              sizeof(theRect),
  2108.                                                              dataDesc);
  2109.                 break;
  2110.             
  2111.             case pPosition:
  2112.             
  2113.                 thePoint.v = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox.top;
  2114.                 thePoint.h = (*((WindowPeek)theWindowPropToken.tokenWindowToken)->strucRgn)->rgnBBox.left;
  2115.                             
  2116.                 theErr   = AECreateDesc(typeQDPoint,
  2117.                                                               (Ptr)&thePoint,
  2118.                                                               sizeof(thePoint),
  2119.                                                               dataDesc);
  2120.                 break;
  2121.                         
  2122.             case pVisible:
  2123.             
  2124.                 theBoolean = ((WindowPeek)theWindowPropToken.tokenWindowToken)->visible;
  2125.                                 
  2126.                 theErr  = AECreateDesc(typeBoolean,
  2127.                                                              (Ptr)&theBoolean,
  2128.                                                              sizeof(theBoolean),
  2129.                                                              dataDesc);
  2130.                 break;
  2131.             
  2132.             case pIsModal:
  2133.             
  2134.                 theBoolean = false;
  2135.                                 
  2136.                 theErr  = AECreateDesc(typeBoolean,
  2137.                                                              (Ptr)&theBoolean,
  2138.                                                              sizeof(theBoolean),
  2139.                                                              dataDesc);
  2140.                 break;
  2141.             
  2142.             case pShowBorders:
  2143.             
  2144.                 theDocument  = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2145.                 theBoolean   = theDocument->showBorders;
  2146.                                 
  2147.                 theErr  = AECreateDesc(typeBoolean,
  2148.                                                              (Ptr)&theBoolean,
  2149.                                                              sizeof(theBoolean),
  2150.                                                              dataDesc);
  2151.                 break;
  2152.             
  2153.             case pIsZoomed:
  2154.             
  2155.                 if (((WindowPeek)theWindowPropToken.tokenWindowToken)->spareFlag) 
  2156.                     {
  2157.                         SetPort(theWindowPropToken.tokenWindowToken);
  2158.                         
  2159.                         userRect = **((RectHandle)((WindowPeek)qd.thePort)->dataHandle);
  2160.                         winRect  = qd.thePort->portRect;
  2161.                         LocalToGlobal((Point *)&winRect.top);
  2162.                         LocalToGlobal((Point *)&winRect.bottom);
  2163.                         
  2164.                         theBoolean = !EqualRect(&userRect, &winRect);
  2165.                     }
  2166.                 else
  2167.                     theBoolean = false;
  2168.                                 
  2169.                 theErr  = AECreateDesc(typeBoolean,
  2170.                                                              (Ptr)&theBoolean,
  2171.                                                              sizeof(theBoolean),
  2172.                                                              dataDesc);
  2173.                 break;
  2174.             
  2175.             case pIsResizable:
  2176.             case pHasTitleBar:
  2177.             case pHasCloseBox:
  2178.             case pIsZoomable :
  2179.             
  2180.                 theBoolean = true;
  2181.                                 
  2182.                 theErr  = AECreateDesc(typeBoolean,
  2183.                                                              (Ptr)&theBoolean,
  2184.                                                              sizeof(theBoolean),
  2185.                                                              dataDesc);
  2186.                 break;
  2187.         
  2188.             case pIsFloating:
  2189.             
  2190.                 theBoolean = false;
  2191.                                 
  2192.                 theErr  = AECreateDesc(typeBoolean,
  2193.                                                              (Ptr)&theBoolean,
  2194.                                                              sizeof(theBoolean),
  2195.                                                              dataDesc);
  2196.                 break;
  2197.             
  2198.             case pIsModified:
  2199.             
  2200.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2201.                 
  2202.                 theBoolean  = theDocument->dirty;
  2203.                 
  2204.                 theErr  = AECreateDesc(typeBoolean,
  2205.                                                              (Ptr)&theBoolean,
  2206.                                                              sizeof(theBoolean),
  2207.                                                              dataDesc);
  2208.                 break;
  2209.             
  2210.             case pIndex:
  2211.             
  2212.                 theIndex = 0;
  2213.                 if (theWindowPropToken.tokenWindowToken) 
  2214.                     do
  2215.                         theIndex++;
  2216.                     while (theWindowPropToken.tokenWindowToken != GetWindowPtrOfNthWindow(theIndex));
  2217.                                 
  2218.                 theErr  = AECreateDesc(typeShortInteger,
  2219.                                                              (Ptr)&theIndex,
  2220.                                                              sizeof(theIndex),
  2221.                                                              dataDesc);
  2222.                 break;
  2223.             
  2224.             case pPageSetup:
  2225.             
  2226.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2227.                 
  2228.                 HLock((Handle)theDocument->thePrintSetup);
  2229.                 
  2230.                 theErr  = AECreateDesc(typeTPrint,
  2231.                                                              (Ptr)*(theDocument->thePrintSetup),
  2232.                                                              sizeof(TPrint),
  2233.                                                              dataDesc);
  2234.                                                              
  2235.                 HUnlock((Handle)theDocument->thePrintSetup);
  2236.                                                              
  2237.                 break;
  2238.             
  2239.             case pSelection:
  2240.             
  2241.                 theDocument = DPtrFromWindowPtr(theWindowPropToken.tokenWindowToken);
  2242.                 
  2243.                 theErr  = MakeSelTextObj( theWindowPropToken.tokenWindowToken,
  2244.                                                                     theDocument->theText, 
  2245.                                                                     dataDesc);                                                             
  2246.                 break;
  2247.             
  2248.             case pDefaultType:
  2249.             case pBestType:
  2250.             
  2251.                 theErr  = MakeWindowObj(theWindowPropToken.tokenWindowToken,
  2252.                                                                 dataDesc);                                                             
  2253.                 break;
  2254.             
  2255.             case pClass:
  2256.             
  2257.                 theErr  = MakeClassObj(cWindow, dataDesc);                                                             
  2258.                 break;
  2259.                 
  2260.         default:
  2261.                 theErr = errAEEventNotHandled;
  2262.         }
  2263.         return(theErr);
  2264.     } /* GetWindowProperty */
  2265.     
  2266. /** -----------------------------------------------------------------------
  2267.         Name:             GetApplicationProperty
  2268.         Purpose:        Fills dataDesc with the requested application property.
  2269.      -----------------------------------------------------------------------**/
  2270.      
  2271. pascal OSErr GetApplicationProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  2272.     {
  2273.       OSErr         theErr;
  2274.         OSErr         ignoreErr;
  2275.         Str255        theName;
  2276.         Boolean       isFront;
  2277.         applPropToken theApplPropToken;
  2278.         AEDesc        newDesc;
  2279.         Size          tokenSize;
  2280.         
  2281.         theErr = AECoerceDesc(theObjToken, typeMyApplProp, &newDesc);
  2282.         if (theErr==noErr)
  2283.             {
  2284.                 GetRawDataFromDescriptor(&newDesc,
  2285.                                                                  (Ptr)&theApplPropToken,
  2286.                                                                  sizeof(theApplPropToken),
  2287.                                                                  &tokenSize);
  2288.                                                                  
  2289.                 ignoreErr = AEDisposeDesc(&newDesc);
  2290.             }
  2291.         else
  2292.           return(theErr);
  2293.  
  2294.         theErr = kAEGenericErr;
  2295.         
  2296.         switch (theApplPropToken.tokenApplProperty) {
  2297.         
  2298.             case pName:
  2299.             
  2300.                     PLstrcpy((StringPtr)theName, "\pMenuScripter");
  2301.                     theErr  = AECreateDesc(typeChar,
  2302.                                                                  (Ptr)&theName[1],
  2303.                                                                  theName[0],
  2304.                                                                  dataDesc);
  2305.                     break;
  2306.             
  2307.             case pVersion:
  2308.             
  2309.                     PLstrcpy((StringPtr)theName, "\p1.0d4");
  2310.                     theErr  = AECreateDesc(typeChar,
  2311.                                                                  (Ptr)&theName[1],
  2312.                                                                  theName[0],
  2313.                                                                  dataDesc);
  2314.                     break;
  2315.         
  2316.             case pIsFrontProcess:
  2317.             
  2318.                     isFront = !gInBackground;
  2319.                     theErr  = AECreateDesc(typeBoolean,
  2320.                                                                  (Ptr)&isFront,
  2321.                                                                  sizeof(isFront),
  2322.                                                                  dataDesc);
  2323.                     break;
  2324.         
  2325.             case pDefaultType:
  2326.             case pBestType:
  2327.             
  2328.                     theErr  = AECreateDesc(typeNull,
  2329.                                                                  nil,
  2330.                                                                  0,
  2331.                                                                  dataDesc);
  2332.                     break;
  2333.             
  2334.             case pClass: 
  2335.             
  2336.                     theErr  = MakeClassObj(cApplication, dataDesc);
  2337.                     break;
  2338.             
  2339.             default:
  2340.             
  2341.                     theErr = errAEEventNotHandled;
  2342.         }
  2343.         
  2344.         return(theErr);
  2345.         
  2346.     } /* GetApplicationProperty */
  2347.      
  2348. /** -----------------------------------------------------------------------
  2349.         Name:             GetMenuProperty
  2350.         Purpose:        Fills dataDesc with the requested menu property.
  2351.      -----------------------------------------------------------------------**/
  2352.      
  2353. pascal OSErr GetMenuProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  2354.     {
  2355.       OSErr         theErr;
  2356.         OSErr         ignoreErr;
  2357.         Str255        theName;
  2358.         MenuPropToken theMenuPropToken;
  2359.         AEDesc        newDesc;
  2360.         Size          tokenSize;
  2361.         short         activeItem;
  2362.         
  2363.         theErr = AECoerceDesc(theObjToken, typeMyMenuProp, &newDesc);
  2364.         if (theErr==noErr)
  2365.             {
  2366.                 GetRawDataFromDescriptor(&newDesc,
  2367.                                                                  (Ptr)&theMenuPropToken,
  2368.                                                                  sizeof(theMenuPropToken),
  2369.                                                                  &tokenSize);
  2370.                                                                  
  2371.                 ignoreErr = AEDisposeDesc(&newDesc);
  2372.             }
  2373.         else
  2374.           return(theErr);
  2375.  
  2376.         switch (theMenuPropToken.theMenuProp) {
  2377.             case pName : 
  2378.             
  2379.                     PLstrcpy(theName, (**theMenuPropToken.theMenuToken.theTokenMenu).menuData);
  2380.                     theErr  = AECreateDesc(typeChar,
  2381.                                                                  (Ptr)&theName[1],
  2382.                                                                  theName[0],
  2383.                                                                  dataDesc);
  2384.                     break;
  2385.                 
  2386.             case pMenuID:
  2387.             
  2388.                     theErr  = AECreateDesc(typeShortInteger,
  2389.                                                                  (Ptr)&theMenuPropToken.theMenuToken.theTokenID,
  2390.                                                                  sizeof(theMenuPropToken.theMenuToken.theTokenID),
  2391.                                                                  dataDesc);
  2392.                     break;
  2393.                     
  2394.             case pActiveItem:
  2395.             
  2396.                     activeItem = GetScriptActiveItem();
  2397.                 
  2398.                     theErr  = AECreateDesc(typeShortInteger,
  2399.                                                                  (Ptr)&activeItem,
  2400.                                                                  sizeof(activeItem),
  2401.                                                                  dataDesc);
  2402.                     break;    
  2403.             
  2404.             case pDefaultType:
  2405.             case pBestType:
  2406.             
  2407.                     PLstrcpy(theName, (**theMenuPropToken.theMenuToken.theTokenMenu).menuData);
  2408.                     
  2409.                     theErr  = MakeMenuObj(theName, dataDesc);
  2410.                     break;
  2411.             
  2412.             case pClass:
  2413.             
  2414.                     theErr  = MakeClassObj(cMenu, dataDesc);
  2415.                     
  2416.                     break;
  2417.                     
  2418.          default:
  2419.                     theErr = errAEEventNotHandled;
  2420.         }
  2421.         
  2422.         return(theErr);
  2423.     } /* GetMenuProperty */
  2424.     
  2425. /** -----------------------------------------------------------------------
  2426.         Name:             GetMenuItemProperty
  2427.         Purpose:        Fills dataDesc with the requested menu property.
  2428.      -----------------------------------------------------------------------**/
  2429.      
  2430. pascal OSErr GetMenuItemProperty(const AEDesc *theObjToken, AEDesc *dataDesc)
  2431.     {
  2432.       OSErr             theErr;
  2433.         OSErr             ignoreErr;
  2434.         Str255            theName;
  2435.         MenuItemPropToken theMenuItemPropToken;
  2436.         AEDesc            newDesc;
  2437.         Size              tokenSize;
  2438.         
  2439.         theErr = AECoerceDesc(theObjToken, typeMyItemProp, &newDesc);
  2440.         if (theErr==noErr)
  2441.             {
  2442.                 GetRawDataFromDescriptor(&newDesc,
  2443.                                                                  (Ptr)&theMenuItemPropToken,
  2444.                                                                  sizeof(theMenuItemPropToken),
  2445.                                                                  &tokenSize);
  2446.                                                                  
  2447.                 ignoreErr = AEDisposeDesc(&newDesc);
  2448.             }
  2449.         else
  2450.           return(theErr);
  2451.  
  2452.         switch (theMenuItemPropToken.theItemProp) {
  2453.         
  2454.             case pName :
  2455.                             GetItem(theMenuItemPropToken.theItemToken.theMenuToken.theTokenMenu,
  2456.                                             theMenuItemPropToken.theItemToken.theTokenItem,
  2457.                                             theName);
  2458.                             theErr  = AECreateDesc(typeChar,
  2459.                                                                          (Ptr)&theName[1],
  2460.                                                                          theName[0],
  2461.                                                                          dataDesc);
  2462.                             break;
  2463.             
  2464.             case pItemNumber:
  2465.         
  2466.                             theErr  = AECreateDesc(typeShortInteger,
  2467.                                                                          (Ptr)&theMenuItemPropToken.theItemToken.theTokenItem,
  2468.                                                                          sizeof(theMenuItemPropToken.theItemToken.theTokenItem),
  2469.                                                                          dataDesc);
  2470.                             break;
  2471.                             
  2472.             case pDefaultType:
  2473.             case pBestType:
  2474.                             
  2475.                             PLstrcpy(theName, (**theMenuItemPropToken.theItemToken.theMenuToken.theTokenMenu).menuData);
  2476.                             
  2477.                             theErr  = MakeMenuItemObj(theName,
  2478.                                                                                 theMenuItemPropToken.theItemToken.theTokenItem,
  2479.                                                                                 dataDesc);
  2480.                             break;
  2481.                             
  2482.             case pClass:
  2483.                             
  2484.                             theErr  = MakeClassObj(cMenuItem, dataDesc);
  2485.                             break;
  2486.                             
  2487.             default: 
  2488.                             theErr = errAEEventNotHandled;
  2489.                             
  2490.         }
  2491.             
  2492.         return(theErr);
  2493.     } /* GetMenuItemProperty */
  2494.  
  2495. /** -----------------------------------------------------------------------
  2496.         Name:             HandleGetData
  2497.         Purpose:        Coerces theObj into a token which we understand and
  2498.                                 extracts the data requested in the token and puts it
  2499.                                 into dataDesc.
  2500.      -----------------------------------------------------------------------**/
  2501.      
  2502. typedef char chars[32001];
  2503. typedef chars **charsHandle;
  2504.  
  2505. pascal OSErr HandleGetData(AEDesc *theObj, DescType whatType, AEDesc *dataDesc)
  2506.   {
  2507. #pragma unused (whatType)
  2508.  
  2509.       OSErr           myErr;
  2510.         OSErr                        ignoreErr;
  2511.         AEDesc          newDesc;
  2512.         TextToken       theTextToken;
  2513.         Size            tokenSize;
  2514.         DPtr            theDoc;
  2515.         AEDesc          objTokenDesc;
  2516.         
  2517.         /*
  2518.             Resolve theObj into a token which we can use - 
  2519.                  get the property or data for that token
  2520.         */    
  2521.     
  2522.         myErr = AEResolve(theObj ,kAEIDoMinimum, &objTokenDesc);
  2523.         
  2524.         if (myErr == noErr)    
  2525.             switch (objTokenDesc.descriptorType){
  2526.             
  2527.                 case typeMyApplProp : myErr = GetApplicationProperty(&objTokenDesc, dataDesc);
  2528.                                                             break;
  2529.                                                             
  2530.                 case typeMyMenuProp : myErr = GetMenuProperty(&objTokenDesc, dataDesc);
  2531.                                                             break;
  2532.                 
  2533.                 case typeMyItemProp : myErr = GetMenuItemProperty(&objTokenDesc, dataDesc);
  2534.                                                             break;
  2535.                 
  2536.                 case typeMyTextProp : myErr = GetTextProperty(&objTokenDesc, dataDesc);
  2537.                                                             break;
  2538.                 
  2539.                 case typeMyWindowProp:myErr = GetWindowProperty(&objTokenDesc, dataDesc);
  2540.                                                             break;
  2541.                 
  2542.                 case typeMyText     :if (AECoerceDesc(&objTokenDesc, typeMyText, &newDesc) == noErr) 
  2543.                                                             {
  2544.                                                                 GetRawDataFromDescriptor(&newDesc,
  2545.                                                                                                                  (Ptr)&theTextToken,
  2546.                                                                                                                  sizeof(theTextToken),
  2547.                                                                                                                  &tokenSize);
  2548.                                                                 
  2549.                                                                 ignoreErr = AEDisposeDesc(&newDesc);
  2550.                                                                                                                  
  2551.                                                                 theDoc = DPtrFromWindowPtr(theTextToken.tokenWindow);
  2552.                                                                 
  2553.                                                                 myErr = BuildStyledTextDesc(theDoc->theText,
  2554.                                                                                                                         theTextToken.tokenOffset,
  2555.                                                                                                                         theTextToken.tokenLength,
  2556.                                                                                                                         dataDesc);
  2557.                                             
  2558.                                                             }
  2559.                                                          break;
  2560.                                                          
  2561.                 default : myErr = errAEWrongDataType;
  2562.             }
  2563.         return(myErr);
  2564.     }    /* HandleGetData */
  2565.  
  2566. /** -----------------------------------------------------------------------
  2567.         Name:             CheckSender
  2568.         Purpose:        Finds the Sender of the AppleEvent.
  2569.      -----------------------------------------------------------------------**/
  2570.      
  2571. pascal void CheckSender(const AppleEvent *theAppleEvent)
  2572.     {
  2573.         OSErr    myErr;
  2574.         TargetID sender;
  2575.         DescType returnedType;
  2576.         Size     actSize;
  2577.         
  2578.         myErr = AEGetAttributePtr(theAppleEvent,
  2579.                                                             keyAddressAttr,
  2580.                                                             typeTargetID,
  2581.                                                             &returnedType,
  2582.                                                             (Ptr)&sender,
  2583.                                                             sizeof(sender),
  2584.                                                             &actSize);
  2585.                                                             
  2586.         // DebugStr((Str255)sender.name.name);
  2587.     }
  2588.  
  2589. /** -----------------------------------------------------------------------
  2590.         Name:             DoGetData
  2591.         Purpose:        Handles the GetData AppleEvent.
  2592.      -----------------------------------------------------------------------**/
  2593.  
  2594. pascal OSErr DoGetData(const AppleEvent *theAppleEvent,
  2595.                                          AppleEvent *reply,
  2596.                                          long handlerRefCon)
  2597.     { 
  2598. #pragma unused (handlerRefCon)
  2599.  
  2600.         OSErr    myErr;
  2601.         OSErr    tempErr;
  2602.         AEDesc   myDirObj;
  2603.         AEDesc   myDataDesc;
  2604.         Size     actualSize;
  2605.         DescType returnedType;
  2606.         DescType reqType;
  2607.         
  2608.         myDataDesc.dataHandle = nil;
  2609.         myDirObj.dataHandle   = nil;
  2610.         
  2611.         /*
  2612.             CheckSender(theAppleEvent);
  2613.         */
  2614.         
  2615.         /*
  2616.             extract the direct object, which is the object whose data is to be returned
  2617.         */
  2618.         
  2619.         myErr  = AEGetParamDesc(theAppleEvent,
  2620.                                                         keyDirectObject,
  2621.                                                         typeWildCard,
  2622.                                                         &myDirObj);
  2623.             
  2624.         /*
  2625.             now the get the type of data wanted - optional
  2626.         */
  2627.         
  2628.         tempErr = AEGetParamPtr(theAppleEvent,
  2629.                                                         keyAERequestedType,
  2630.                                                         typeType,
  2631.                                                         &returnedType,
  2632.                                                         (Ptr)&reqType,
  2633.                                                         sizeof(reqType),
  2634.                                                         &actualSize);
  2635.         if (tempErr!=noErr) 
  2636.             reqType = typeChar;
  2637.             
  2638.         if (myErr == noErr) 
  2639.             myErr = GotRequiredParams(theAppleEvent);
  2640.         
  2641.         /* get the data */
  2642.         if (myErr == noErr) 
  2643.             myErr = HandleGetData(&myDirObj, reqType, &myDataDesc);
  2644.             
  2645.         /* if they wanted a reply, attach it now */
  2646.         if (myErr==noErr) 
  2647.             if (reply->descriptorType != typeNull) 
  2648.                 myErr = AEPutParamDesc(reply, keyDirectObject, &myDataDesc);
  2649.                 
  2650.     if (myDataDesc.dataHandle)
  2651.           tempErr = AEDisposeDesc(&myDataDesc);
  2652.  
  2653.     if (myDirObj.dataHandle)
  2654.           tempErr = AEDisposeDesc(&myDirObj);
  2655.             
  2656.         return(myErr);
  2657.     }    /* DoGetData */
  2658.  
  2659.  
  2660. /** -----------------------------------------------------------------------
  2661.         Name:             DoGetDataSize
  2662.         Purpose:        Handles the GetDataSize AppleEvent.
  2663.      -----------------------------------------------------------------------**/
  2664.  
  2665. pascal OSErr DoGetDataSize(const AppleEvent *theAppleEvent,
  2666.                                                         AppleEvent *reply,
  2667.                                                                  long       handlerRefCon)
  2668.   { 
  2669. #pragma unused (handlerRefCon)
  2670.     
  2671.         OSErr     myErr;
  2672.         OSErr     tempErr;
  2673.         AEDesc    myDirObj;
  2674.         AEDesc    myDataDesc;
  2675.         Size      actualSize;
  2676.         DescType  returnedType;
  2677.         DescType  reqType;
  2678.         long      dataSize;
  2679.         
  2680.         myDataDesc.dataHandle = nil;
  2681.         myDirObj.dataHandle   = nil;
  2682.         
  2683.         /* pick up the direct object, which is the object whose data is to be sized */
  2684.         
  2685.         myErr  = AEGetParamDesc(theAppleEvent,
  2686.                                                         keyDirectObject,
  2687.                                                         typeWildCard,
  2688.                                                         &myDirObj);
  2689.             
  2690.         /* now the get the type wanted - optional*/
  2691.         
  2692.         tempErr = AEGetParamPtr(theAppleEvent,
  2693.                                                         keyAERequestedType,
  2694.                                                         typeType,
  2695.                                                         &returnedType,
  2696.                                                         (Ptr)&reqType,
  2697.                                                         sizeof(reqType),
  2698.                                                         &actualSize);
  2699.         
  2700.         if (tempErr!=noErr) 
  2701.             reqType = typeChar;
  2702.             
  2703.         if (myErr == noErr) 
  2704.             myErr = GotRequiredParams(theAppleEvent);
  2705.         
  2706.         /* get the data */
  2707.         if (myErr == noErr) 
  2708.             myErr = HandleGetData(&myDirObj, reqType, &myDataDesc);
  2709.             
  2710.         /* evaluate size of data and discard, create desc for size */
  2711.         if (myErr == noErr) 
  2712.             if (myDataDesc.dataHandle) 
  2713.                 {
  2714.                     dataSize = GetHandleSize((Handle)myDataDesc.dataHandle);
  2715.                     DisposHandle((Handle)myDataDesc.dataHandle);
  2716.                     myErr  = AECreateDesc(typeLongInteger,
  2717.                                                                 (Ptr)&dataSize,
  2718.                                                                 sizeof(dataSize),
  2719.                                                                 &myDataDesc);
  2720.                 }
  2721.             
  2722.             
  2723.         /* if they wanted a reply, attach it now */
  2724.         
  2725.         if (myErr==noErr) 
  2726.             if (reply->descriptorType != typeNull) 
  2727.                 myErr = AEPutParamDesc(reply, keyDirectObject, &myDataDesc);
  2728.                 
  2729.         /* discard our copy */
  2730.         
  2731.         if (myDataDesc.dataHandle) 
  2732.             tempErr = AEDisposeDesc(&myDataDesc);
  2733.                 
  2734.         if (myDirObj.dataHandle) 
  2735.             tempErr = AEDisposeDesc(&myDirObj);
  2736.                 
  2737.         return(myErr);
  2738.     }    /* DoGetDataSize */
  2739.  
  2740. /** -----------------------------------------------------------------------
  2741.         Name:             DoNewElement
  2742.         Purpose:        Handles the NewElement AppleEvent. Only Creates windows for
  2743.                     now.
  2744.      -----------------------------------------------------------------------**/
  2745.  
  2746. pascal OSErr DoNewElement(const AppleEvent *theAppleEvent,
  2747.                                                 AppleEvent *reply, 
  2748.                                                 long       handlerRefCon)
  2749. {
  2750. #pragma unused (handlerRefCon)
  2751.  
  2752.     OSErr       myErr;
  2753.     OSErr       ignoreErr;
  2754.     DescType      returnedType;
  2755.     DescType      newElemClass;
  2756.     Size        actSize;
  2757.     AEDesc        wndwObjSpec;
  2758.     DPtr        theDoc;
  2759.     
  2760.     wndwObjSpec.dataHandle = nil;
  2761.         
  2762.     myErr = AEGetParamPtr(theAppleEvent,
  2763.                                                 keyAEObjectClass,
  2764.                                                 typeType,
  2765.                                                 &returnedType,
  2766.                                                 (Ptr)&newElemClass,
  2767.                                                 sizeof(newElemClass),
  2768.                                                 &actSize);
  2769.             
  2770.   /* check for missing required parameters */
  2771.     
  2772.   if (myErr == noErr) 
  2773.         myErr = GotRequiredParams(theAppleEvent);
  2774.   
  2775.   /* got all required params */
  2776.   
  2777.   /* let's make sure container is the null desc */
  2778.   /* and they want a window */
  2779.     
  2780.   if (newElemClass != cWindow) 
  2781.     myErr = errAEWrongDataType;
  2782.   
  2783.   /* let's create a new window */
  2784.     
  2785.     if (myErr == noErr) 
  2786.         theDoc = NewDocument(false);
  2787.   
  2788.     if (myErr==noErr)
  2789.         if (theDoc == nil) 
  2790.             myErr = -1700;
  2791.         else
  2792.             {
  2793.                 ShowWindow(theDoc->theWindow);
  2794.                 theDoc->dirty = false;
  2795.             
  2796.                 myErr = MakeWindowObj(theDoc->theWindow, &wndwObjSpec);
  2797.             }
  2798.       
  2799.     if (myErr == noErr) 
  2800.         if (reply->descriptorType != typeNull) 
  2801.              myErr = AEPutParamDesc(reply,
  2802.                                                             keyDirectObject,
  2803.                                                             &wndwObjSpec);
  2804.             
  2805.     if (wndwObjSpec.dataHandle) 
  2806.         ignoreErr = AEDisposeDesc(&wndwObjSpec);
  2807.         
  2808.   return(myErr);
  2809. }    /* DoNewElement */
  2810.  
  2811. /** -----------------------------------------------------------------------
  2812.         Name:             DoIsThereA
  2813.         Purpose:        Handles the IsThereA AppleEvent.
  2814.      -----------------------------------------------------------------------**/
  2815.  
  2816. pascal OSErr DoIsThereA(const AppleEvent *theAppleEvent,
  2817.                                             AppleEvent       *reply, 
  2818.                                             long             handlerRefCon)
  2819.                                             
  2820. /*
  2821.     Support check of Windows at first
  2822.     
  2823.     What we do :
  2824.         Get Direct Object
  2825.         Check have all required params
  2826.         Coerce into things we support
  2827.         if we get something back
  2828.             check to see it exists and set reply
  2829.         clean up
  2830.         return
  2831. */
  2832.  
  2833.  {
  2834. #pragma unused (handlerRefCon)
  2835.  
  2836.         OSErr         myErr;
  2837.         OSErr         ignoreErr;
  2838.         AEDesc        myDirObject;
  2839.         AEDesc        windDesc;
  2840.         AEDesc        dataDesc;
  2841.         WindowToken   theWindowToken;
  2842.         Size          tokenSize;
  2843.         Boolean       exists;
  2844.  
  2845.         myDirObject.dataHandle = nil;
  2846.         windDesc.dataHandle    = nil;
  2847.         dataDesc.dataHandle    = nil;
  2848.                 
  2849.         myErr = AEGetParamDesc(theAppleEvent,
  2850.                                                      keyDirectObject,
  2851.                                                      typeWildCard,
  2852.                                                      &myDirObject);
  2853.                         
  2854.         /* check for missing required parameters */
  2855.         
  2856.         if (myErr == noErr) 
  2857.             myErr = GotRequiredParams(theAppleEvent);
  2858.         
  2859.         /* got all required params */
  2860.         
  2861.         /* let's make sure they want to check for a window */
  2862.             
  2863.         exists = false;
  2864.         
  2865.         if (myErr == noErr) 
  2866.             if (AECoerceDesc(&myDirObject, typeMyWndw, &windDesc)==noErr) 
  2867.                 if (windDesc.descriptorType!=typeNull) 
  2868.                     {
  2869.                         GetRawDataFromDescriptor(&windDesc,
  2870.                                                                          (Ptr)&theWindowToken,
  2871.                                                                          sizeof(theWindowToken),
  2872.                                                                          &tokenSize);
  2873.                                                                          
  2874.                         exists = (theWindowToken != nil);    
  2875.                     }
  2876.                     
  2877.         if (myErr == noErr) 
  2878.             myErr = AECreateDesc(typeBoolean,
  2879.                                                      (Ptr)&exists,
  2880.                                                      sizeof(exists),
  2881.                                                      &dataDesc);
  2882.     
  2883.             
  2884.         /* 
  2885.             if they wanted a reply, which they surely must, 
  2886.             attach the result to it…
  2887.         */
  2888.             
  2889.         if (myErr == noErr)
  2890.             if (reply->descriptorType != typeNull) 
  2891.                  myErr = AEPutParamDesc(reply,
  2892.                                                                 keyDirectObject,
  2893.                                                                 &dataDesc);
  2894.                 
  2895.         if (dataDesc.dataHandle) 
  2896.             ignoreErr = AEDisposeDesc(&dataDesc);
  2897.             
  2898.         if (myDirObject.dataHandle) 
  2899.             ignoreErr = AEDisposeDesc(&myDirObject);
  2900.             
  2901.         if (windDesc.dataHandle) 
  2902.             ignoreErr = AEDisposeDesc(&windDesc);
  2903.             
  2904.         return(myErr);
  2905.     }    /* DoIsThereA */
  2906.  
  2907. /** -----------------------------------------------------------------------
  2908.         Name:             DoCloseWindow
  2909.         Purpose:        Handles the Close AppleEvent.
  2910.      -----------------------------------------------------------------------**/
  2911.  
  2912. pascal OSErr DoCloseWindow(const AppleEvent *theAppleEvent,
  2913.                                                     AppleEvent       *reply,
  2914.                                                     long             handlerRefCon)
  2915.     { 
  2916. #pragma unused (reply, handlerRefCon)
  2917.  
  2918.         OSErr         myErr;
  2919.         OSErr         tempErr;
  2920.         OSErr                 ignoreErr;
  2921.         AEDesc        myDirObj;
  2922.         AEDesc        newDesc;
  2923.         WindowToken   theWindowToken;
  2924.         Size          tokenSize;
  2925.         DescType      saveOpt;
  2926.         Size          actSize;
  2927.         DescType      returnedType;
  2928.         DPtr          myDPtr;
  2929.  
  2930.         myDirObj.dataHandle = nil;
  2931.         
  2932.         /* pick up the direct object, which is the object (window) to close */
  2933.         
  2934.         myErr = AEGetParamDesc(theAppleEvent,
  2935.                                                      keyDirectObject,
  2936.                                                      typeWildCard,
  2937.                                                      &myDirObj);
  2938.                     
  2939.         /* pick up optional save param, if any */
  2940.         
  2941.         saveOpt = kAEAsk; /* the default */
  2942.         
  2943.         tempErr = AEGetParamPtr(theAppleEvent,
  2944.                                                         keyAESaveOptions,
  2945.                                                         typeEnumerated,
  2946.                                                         &returnedType,
  2947.                                                         (Ptr)&saveOpt,
  2948.                                                         sizeof(saveOpt),
  2949.                                                         &actSize);
  2950.                                                          
  2951.         if (myErr == noErr)
  2952.             myErr = GotRequiredParams(theAppleEvent);
  2953.             
  2954.         /* get the window to close as a window ptr */
  2955.         if (myErr == noErr) 
  2956.             if (AECoerceDesc(&myDirObj, typeMyWndw, &newDesc)==noErr) 
  2957.                 if (newDesc.descriptorType!=typeNull) 
  2958.                     {
  2959.                         GetRawDataFromDescriptor(&newDesc,
  2960.                                                                          (Ptr)&theWindowToken,
  2961.                                                                          sizeof(theWindowToken),
  2962.                                                                          &tokenSize);
  2963.                                                                          
  2964.                         ignoreErr = AEDisposeDesc(&newDesc);
  2965.                         
  2966.                         if (theWindowToken) 
  2967.                             {
  2968.                                 myErr=AESetInteractionAllowed(kAEInteractWithAll); /* Should do this in prefs */
  2969.                                 
  2970.                                 /*
  2971.                                     We do some of the close checks here to avoid
  2972.                                     calling AEInteractWithUser
  2973.                                 */
  2974.                                 myDPtr = DPtrFromWindowPtr(theWindowToken);
  2975.                                 if ((myDPtr->dirty) || (myDPtr->everSaved == false)) 
  2976.                                     if (saveOpt != kAENo) /* Don't flip layers if force no ask */
  2977.                                         myErr = AEInteractWithUser(kAEDefaultTimeout, nil, nil);
  2978.                                     
  2979.                                 if (myErr==noErr) 
  2980.                                     myErr = DoClose(theWindowToken, true, saveOpt);
  2981.                             }
  2982.                         else
  2983.                             myErr =  errAEIllegalIndex;
  2984.                     }
  2985.                         
  2986.         if (myDirObj.dataHandle) 
  2987.             tempErr = AEDisposeDesc(&myDirObj);
  2988.                 
  2989.         return(myErr);
  2990.     }    /* DoCloseWindow */
  2991.  
  2992. /** -----------------------------------------------------------------------
  2993.         Name:             IndexFromWindowPtr
  2994.         Purpose:        calculates index of WindowPtr.
  2995.                     1 == frontmost window
  2996.                                 0 == no window
  2997.                                 n == n-1 behind first window
  2998.      -----------------------------------------------------------------------**/
  2999.  
  3000. pascal short IndexFromWindowPtr(WindowPtr theWindowPtr)
  3001.  {
  3002.          short     index;
  3003.         WindowPtr checkWin;
  3004.         
  3005.         index = 0;
  3006.         checkWin = (WindowPtr)*((Handle)WindowList);
  3007.          
  3008.         //    iterate through windows - we use WindowList to see all windows visible or not
  3009.         
  3010.         while (checkWin)
  3011.             {
  3012.                 index++;
  3013.                 
  3014.                 if (checkWin==theWindowPtr)
  3015.                     return(index);
  3016.                     
  3017.               checkWin = (WindowPtr)((WindowPeek)checkWin)->nextWindow;
  3018.             }
  3019.             
  3020.         return(0);
  3021.  }
  3022.  
  3023. /** -----------------------------------------------------------------------
  3024.         Name:             MoveWindowRelative
  3025.         Purpose:        Moves one window relative to another.
  3026.      -----------------------------------------------------------------------**/
  3027.  
  3028. pascal OSErr MoveWindowRelative(WindowToken theWindowToken,
  3029.                                 WindowToken theRelWindowToken,
  3030.                                                               DescType    theRelPosn)
  3031.     {
  3032.         short win1Index;
  3033.         short win2Index;
  3034.         OSErr myErr = noErr;
  3035.         
  3036.         win1Index = IndexFromWindowPtr(theWindowToken);
  3037.         win2Index = IndexFromWindowPtr(theRelWindowToken);
  3038.         
  3039.         if (theRelPosn==kAEBefore)
  3040.             if (win2Index==1)
  3041.                 {
  3042.                     SelectWindow(theWindowToken); // special case - make frontmost window
  3043.                     return(myErr);
  3044.                 }
  3045.             else
  3046.                 { // in front of 3 == behind 2 so…
  3047.                     win2Index--;
  3048.                 }
  3049.         
  3050.         if (win2Index!=win1Index+1)
  3051.             {
  3052.                 SendBehind(theWindowToken,theRelWindowToken);
  3053.                 
  3054.                 if (win1Index > win2Index + 1)
  3055.                      // Fix up visRgn as per Inside Mac I-286.
  3056.                     {    
  3057.                         PaintOne((WindowPeek)theWindowToken,
  3058.                                          ((WindowPeek)theWindowToken)->strucRgn);
  3059.                         CalcVis((WindowPeek)theWindowToken);
  3060.                     }
  3061.             }
  3062.         return(myErr);
  3063.     }
  3064.  
  3065. /** -----------------------------------------------------------------------
  3066.         Name:             DoMoveWindow
  3067.         Purpose:        Handles the Move AppleEvent for windows.
  3068.      -----------------------------------------------------------------------**/
  3069.  
  3070. pascal OSErr DoMoveWindow(const AppleEvent *theAppleEvent,
  3071.                                                    AppleEvent       *reply,
  3072.                                                    long             handlerRefCon)
  3073.     { 
  3074. #pragma unused (reply, handlerRefCon)
  3075.  
  3076.         OSErr         myErr;
  3077.         OSErr                 ignoreErr;
  3078.         AEDesc        whereToPutIt;
  3079.         AEDesc        theLocationRec;
  3080.         DescType      theRelPosn;
  3081.         WindowToken   theWindowToken;
  3082.         WindowToken   theRefWindowToken;
  3083.         Size          actSize;
  3084.         DescType      returnedType;
  3085.  
  3086.         whereToPutIt.dataHandle   = nil;
  3087.         theLocationRec.dataHandle = nil;
  3088.         
  3089.         /* pick up the direct object, which is the object (window) to move */
  3090.         
  3091.         myErr = AEGetParamPtr(theAppleEvent,
  3092.                                                     keyDirectObject,
  3093.                                                     typeMyWndw,
  3094.                                                     &returnedType,
  3095.                                                     (Ptr)&theWindowToken,
  3096.                                                     sizeof(theWindowToken),
  3097.                                                     &actSize);
  3098.                     
  3099.         /* pick up where to information */
  3100.         
  3101.         if (myErr==noErr)
  3102.             myErr = AEGetParamDesc(theAppleEvent,
  3103.                                                          keyAEInsertHere,
  3104.                                                          typeInsertionLoc,
  3105.                                                          &whereToPutIt);
  3106.                                                          
  3107.         if (myErr==noErr)
  3108.             {
  3109.                 myErr = AECoerceDesc(&whereToPutIt, typeAERecord, &theLocationRec);
  3110.                                 
  3111.                 if (myErr==noErr)
  3112.                     myErr = AEGetKeyPtr(&theLocationRec,
  3113.                                                             keyAEObject,
  3114.                                                             typeMyWndw,
  3115.                                                             &returnedType,
  3116.                                                             (Ptr)&theRefWindowToken,
  3117.                                                             sizeof(theRefWindowToken),
  3118.                                                             &actSize);
  3119.                 if (myErr==noErr)
  3120.                     myErr = AEGetKeyPtr(&theLocationRec,
  3121.                                                             keyAEPosition,
  3122.                                                             typeEnumerated,
  3123.                                                             &returnedType,
  3124.                                                             (Ptr)&theRelPosn,
  3125.                                                             sizeof(theRelPosn),
  3126.                                                             &actSize);
  3127.                                                             
  3128.                 if (theLocationRec.dataHandle)
  3129.                     ignoreErr = AEDisposeDesc(&theLocationRec);
  3130.             }
  3131.                                          
  3132.         if (myErr == noErr)
  3133.             myErr = GotRequiredParams(theAppleEvent);
  3134.  
  3135.         if (theRelPosn==kAEBefore ||
  3136.             theRelPosn==kAEAfter)
  3137.             MoveWindowRelative(theWindowToken, theRefWindowToken, theRelPosn);
  3138.         else
  3139.             myErr = errAEEventNotHandled;
  3140.             
  3141.         if (whereToPutIt.dataHandle)
  3142.             ignoreErr = AEDisposeDesc(&whereToPutIt);
  3143.                     
  3144.         // Now place one window relative to the other
  3145.         
  3146.         return(myErr);
  3147.     }    /* DoMoveWindow */
  3148.  
  3149.  
  3150. /** -----------------------------------------------------------------------
  3151.         Name:             DoSaveWindow
  3152.         Purpose:        Handles the Save AppleEvent.
  3153.      -----------------------------------------------------------------------**/
  3154.  
  3155. pascal OSErr DoSaveWindow(const AppleEvent *theAppleEvent,
  3156.                                                  AppleEvent       *reply,
  3157.                                                  long             handlerRefCon)
  3158.     { 
  3159. #pragma unused (reply, handlerRefCon)
  3160.     
  3161.         OSErr         myErr;
  3162.         OSErr         tempErr;
  3163.         OSErr         ignoreErr;
  3164.         AEDesc        myDirObj;
  3165.         AEDesc        newDesc;
  3166.         WindowToken   theWindowToken;
  3167.         Size          tokenSize;
  3168.         Size          actSize;
  3169.         DescType      returnedType;
  3170.         DPtr          theDoc;
  3171.         FSSpec        destFSSpec;
  3172.         
  3173.         myDirObj.dataHandle = nil;
  3174.         
  3175.         /* pick up the direct object, which is the window to save */
  3176.         
  3177.         myErr = AEGetParamDesc(theAppleEvent,
  3178.                                                      keyDirectObject,
  3179.                                                      typeWildCard,
  3180.                                                      &myDirObj);
  3181.                                                      
  3182.         /* pick up optional destination param, if any */
  3183.     
  3184.         tempErr = AEGetParamPtr(theAppleEvent,
  3185.                                                         keyAEDestination,
  3186.                                                       typeFSS,
  3187.                                                         &returnedType,
  3188.                                                         (Ptr)&destFSSpec,
  3189.                                                         sizeof(destFSSpec),
  3190.                                                         &actSize);
  3191.     
  3192.         if (myErr == noErr) 
  3193.             myErr = GotRequiredParams(theAppleEvent);
  3194.             
  3195.         /* get the data */
  3196.     
  3197.         myErr = AECoerceDesc(&myDirObj, typeMyWndw, &newDesc);
  3198.         
  3199.         if (myErr == noErr)
  3200.             if (newDesc.descriptorType!=typeNull) 
  3201.                 {
  3202.                     GetRawDataFromDescriptor(&newDesc,
  3203.                                                                      (Ptr)&theWindowToken,
  3204.                                                                      sizeof(theWindowToken),
  3205.                                                                      &tokenSize);
  3206.                                                                      
  3207.                     ignoreErr = AEDisposeDesc(&newDesc);
  3208.                                                                      
  3209.                     if (theWindowToken) 
  3210.                         {                            
  3211.                             theDoc = DPtrFromWindowPtr(theWindowToken);
  3212.                             
  3213.                             if (theDoc->everSaved == false) 
  3214.                                 if (tempErr != noErr) 
  3215.                                      /* We had no supplied destination and no default either */
  3216.                                     myErr = kAEGenericErr;
  3217.                             
  3218.                             if (myErr==noErr)
  3219.                                 if (tempErr==noErr)
  3220.                                     { /* we were told where */
  3221.                                         myErr = DoSave(theDoc, destFSSpec); 
  3222.                                         
  3223.                                         if (myErr==noErr)
  3224.                                             AssocAllSections(theDoc);
  3225.                                     }
  3226.                                 else
  3227.                                     myErr = SaveUsingTemp(theDoc);
  3228.                         }
  3229.                     else
  3230.                         myErr =  errAEIllegalIndex;
  3231.                 }
  3232.                 
  3233.         if (myDirObj.dataHandle) 
  3234.             tempErr = AEDisposeDesc(&myDirObj);
  3235.     
  3236.         return(myErr);
  3237.                     
  3238.     }    /* DoSaveWindow */
  3239.  
  3240. /** -----------------------------------------------------------------------
  3241.         Name:             DoRevertWindow
  3242.         Purpose:        Handles the Revert AppleEvent.
  3243.      -----------------------------------------------------------------------**/
  3244.  
  3245. pascal OSErr DoRevertWindow(const AppleEvent *theAppleEvent,
  3246.                                                      AppleEvent       *reply,
  3247.                                                      long             handlerRefCon)
  3248. { 
  3249. #pragma unused (reply, handlerRefCon)
  3250.  
  3251.     OSErr          myErr;
  3252.     OSErr          ignoreErr;
  3253.     AEDesc         myDirObj;
  3254.     AEDesc         newDesc;
  3255.     WindowToken    theWindowToken;
  3256.     Size           tokenSize;
  3257.     DPtr           theDoc;
  3258.     
  3259.     myDirObj.dataHandle = nil;
  3260.     
  3261.   /* pick up the direct object, which is the window to save */
  3262.     
  3263.   myErr = AEGetParamDesc(theAppleEvent,
  3264.                                                  keyDirectObject,
  3265.                                                  typeWildCard,
  3266.                                                  &myDirObj);
  3267.  
  3268.     if (myErr == noErr)
  3269.       myErr = GotRequiredParams(theAppleEvent);
  3270.         
  3271.   /* get the window to revert from the direct object */
  3272.     
  3273.     myErr = AECoerceDesc(&myDirObj, typeMyWndw, &newDesc);
  3274.     
  3275.   if (myErr == noErr) 
  3276.         if (newDesc.descriptorType!=typeNull) 
  3277.             {
  3278.                 GetRawDataFromDescriptor(&newDesc,
  3279.                                                                  (Ptr)&theWindowToken,
  3280.                                                                  sizeof(theWindowToken),
  3281.                                                                  &tokenSize);
  3282.                                                                  
  3283.                 ignoreErr = AEDisposeDesc(&newDesc);
  3284.                                                                  
  3285.                 if (theWindowToken) 
  3286.                     {    
  3287.                         theDoc = DPtrFromWindowPtr(theWindowToken);
  3288.                         
  3289.                         HidePen();
  3290.                         TESetSelect(0, (*(theDoc->theText))->teLength, theDoc->theText);
  3291.                         ShowPen();
  3292.                         TEDelete(theDoc->theText);
  3293.         
  3294.                         if (theDoc->everSaved) 
  3295.                             {
  3296.                                 myErr = GetFileContents(theDoc->theFSSpec, theDoc);
  3297.                                 if (myErr == noErr) 
  3298.                                     {
  3299.                                         ResizeWindow(theDoc);
  3300.                                         theDoc->dirty = false;
  3301.                                     }
  3302.                             }
  3303.         
  3304.                         ShowWindow(theDoc->theWindow); /* <<< Visible already??? */
  3305.                         DoUpdate(theDoc);
  3306.                     }
  3307.                 else
  3308.                     myErr =  errAEIllegalIndex;
  3309.             }
  3310.                 
  3311.     if (myDirObj.dataHandle) 
  3312.         ignoreErr = AEDisposeDesc(&myDirObj);
  3313.         
  3314.   return(myErr);
  3315. }    /* DoRevertWindow */
  3316.  
  3317. /**-----------------------------------------------------------------------
  3318.         Name:             DoPrintDocuments
  3319.         Purpose:        Print a list of documents (or windows).
  3320. -----------------------------------------------------------------------**/
  3321. pascal OSErr DoPrintDocuments(const AppleEvent *message,
  3322.                               AppleEvent       *reply,
  3323.                                                             long refcon)
  3324. {
  3325. #pragma unused (reply, refcon)
  3326.         long          index;
  3327.         long          itemsInList;
  3328.         AEKeyword     keywd;
  3329.         OSErr         err;
  3330.         AEDescList    docList;
  3331.         Size          actSize;
  3332.         DescType      typeCode;
  3333.         FSSpec        theFSSpec;
  3334.         WindowToken   theWindowToken;
  3335.         OSErr         forgetErr;
  3336.         Boolean       talkToUser;
  3337.             
  3338.         err = AEGetParamDesc(message,
  3339.                                                  keyDirectObject,
  3340.                                                  typeAEList,
  3341.                                                  &docList);
  3342.                                                  
  3343.         err = AECountItems(&docList, &itemsInList);
  3344.             
  3345.         for (index = 1; index<=itemsInList; index++)
  3346.             if (err == noErr) 
  3347.                 {
  3348.                     forgetErr = AEGetNthPtr( &docList, index, typeFSS, &keywd,
  3349.                                                                      &typeCode, (Ptr)&theFSSpec, sizeof(theFSSpec), &actSize);
  3350.                                                                         
  3351.                     if (forgetErr == noErr) 
  3352.                         {
  3353.                             if (err == noErr) 
  3354.                                 err = IssueAEOpenDoc(theFSSpec);
  3355.                                 
  3356.                             if (err == noErr) 
  3357.                                 IssuePrintWindow(FrontWindow());
  3358.                                 
  3359.                             if (err == noErr) 
  3360.                                 IssueCloseCommand(FrontWindow());
  3361.                         }
  3362.                     else
  3363.                         { /* wasn't a file - was it a window ? */
  3364.                             err = AEGetNthPtr(&docList,
  3365.                                               index,
  3366.                                               typeMyWndw,
  3367.                                               &keywd,
  3368.                                                                 &typeCode,
  3369.                                                                 (Ptr)&theWindowToken,
  3370.                                                                 sizeof(WindowToken),
  3371.                                                                 &actSize);
  3372.                                                                     
  3373.                             talkToUser = (AEInteractWithUser(kAEDefaultTimeout, nil, nil) == noErr);
  3374.                             
  3375.                             if (err == noErr) 
  3376.                                 PrintWindow(DPtrFromWindowPtr(theWindowToken), talkToUser);
  3377.                         }
  3378.                 }
  3379.         
  3380.         if (docList.dataHandle)
  3381.             forgetErr = AEDisposeDesc(&docList);
  3382.             
  3383.         return(err);
  3384.     } /* DoPrintDocuments */
  3385.  
  3386. /**-----------------------------------------------------------------------
  3387.         Name:             HandleCreatePub
  3388.         Purpose:        Create a publisher.
  3389. -----------------------------------------------------------------------**/
  3390. pascal OSErr HandleCreatePub(const AppleEvent *theAppleEvent,
  3391.                              AppleEvent       *reply,
  3392.                                                          long refcon)
  3393.     {
  3394. #pragma unused (reply, refcon)
  3395.  
  3396.         OSErr       myErr;
  3397.         FSSpec      theFSSpec;
  3398.         OSErr       forgetErr;
  3399.         OSErr       forget2Err;
  3400.         AEDesc      myDirObj;
  3401.         AEDesc      myFileLoc;
  3402.         TextToken   theTextToken;
  3403.         DPtr        theDoc;
  3404.         AEDesc      newDesc;
  3405.         long        tokenSize;
  3406.         Boolean     haveFSSpec;
  3407.         
  3408.         myErr = noErr;
  3409.         
  3410.         forgetErr  = AEGetParamDesc(theAppleEvent,
  3411.                                                                 keyDirectObject,
  3412.                                                                 typeWildCard,
  3413.                                                                 &myDirObj);
  3414.         
  3415.         forget2Err = AEGetParamDesc(theAppleEvent,
  3416.                                                                 keyAEEditionFileLoc,
  3417.                                                                 typeWildCard,
  3418.                                                                 &myFileLoc);
  3419.                                                                  
  3420.         if (myErr==noErr)
  3421.             myErr = GotRequiredParams(theAppleEvent);
  3422.             
  3423.         if (forgetErr==noErr)  /* Set the selection to the supplied object - if any */
  3424.             {
  3425.                 forgetErr = AECoerceDesc(&myDirObj, typeMyText, &newDesc);
  3426.                 if (newDesc.descriptorType!=typeNull) 
  3427.                     {
  3428.                         GetRawDataFromDescriptor(&newDesc,
  3429.                                                                          (Ptr)&theTextToken,
  3430.                                                                          sizeof(theTextToken),
  3431.                                                                          &tokenSize);
  3432.                                                                          
  3433.                         theDoc = DPtrFromWindowPtr(theTextToken.tokenWindow);
  3434.                         
  3435.                         TESetSelect(theTextToken.tokenOffset-1,
  3436.                                                 theTextToken.tokenOffset+
  3437.                                                                     theTextToken.tokenLength-1,
  3438.                                                 theDoc->theText);
  3439.                                                 
  3440.                         forgetErr = AEDisposeDesc(&newDesc);
  3441.                     }
  3442.             }
  3443.         else
  3444.             theDoc = DPtrFromWindowPtr(FrontWindow());
  3445.             
  3446.         if (theDoc==nil) 
  3447.             {
  3448.                 /* Should clean up and exit with error */
  3449.             }
  3450.             
  3451.         haveFSSpec = false;
  3452.         
  3453.         if (forget2Err==noErr)  /* Get the Edition Container File */
  3454.             {
  3455.                 forget2Err = AECoerceDesc(&myDirObj,typeFSS,&newDesc);
  3456.                 if (newDesc.descriptorType!=typeNull) 
  3457.                     {
  3458.                         GetRawDataFromDescriptor(&newDesc,
  3459.                                                                          (Ptr)&theFSSpec,
  3460.                                                                          sizeof(theFSSpec),
  3461.                                                                          &tokenSize);
  3462.                         forget2Err = AEDisposeDesc(&newDesc);
  3463.                         haveFSSpec = true;
  3464.                     }
  3465.             }
  3466.             
  3467.         if (haveFSSpec==false) 
  3468.             myErr = GetEditionContainer(theDoc, &theFSSpec);
  3469.     
  3470.         if (myErr == noErr) 
  3471.             myErr = PublishText(theDoc, &theFSSpec);
  3472.             
  3473.         if (myDirObj.dataHandle)
  3474.             forgetErr = AEDisposeDesc(&myDirObj);
  3475.         
  3476.         if (myFileLoc.dataHandle) 
  3477.             forgetErr = AEDisposeDesc(&myFileLoc);
  3478.         
  3479.         return(myErr);
  3480.         
  3481.     } /* HandleCreatePub */
  3482.  
  3483.  
  3484. pascal OSErr MyCountProc(    DescType desiredType,
  3485.                                                     DescType containerClass,
  3486.                                                     const AEDesc *container,
  3487.                                                     long *result);
  3488.                                             
  3489. /** -----------------------------------------------------------------------
  3490.         Name:       HandleNumberOfElements
  3491.         Purpose:        Handles the Number Of Elements AppleEvent.
  3492.      -----------------------------------------------------------------------**/
  3493.  
  3494. pascal OSErr HandleNumberOfElements(const AppleEvent *theAppleEvent,
  3495.                                                                     AppleEvent *reply,
  3496.                                                                     long       handlerRefCon)
  3497.   {
  3498. #pragma unused (handlerRefCon)
  3499.  
  3500.       OSErr    myErr;
  3501.       OSErr    forgetErr;
  3502.         AEDesc   myDirObj;
  3503.         DescType myClass;
  3504.         long     myCount;
  3505.         DescType returnedType;
  3506.         Size     actSize;
  3507.         
  3508.         myErr                 = errAEEventNotHandled;
  3509.         myDirObj.dataHandle = nil;
  3510.         
  3511.         /* pick up direct object, which is the container in which things are to be counted */
  3512.         
  3513.         myErr = AEGetParamDesc(theAppleEvent,
  3514.                                                      keyDirectObject,
  3515.                                                      typeWildCard,
  3516.                                                      &myDirObj);
  3517.             
  3518.         /* now the class of objects to be counted */
  3519.         
  3520.         myErr = AEGetParamPtr( theAppleEvent,
  3521.                                                      keyAEObjectClass,
  3522.                                                      typeType,
  3523.                                                      &returnedType,
  3524.                                                      (Ptr)&myClass,
  3525.                                                      sizeof(myClass),
  3526.                                                      &actSize);
  3527.             
  3528.         /* missing any parameters? */
  3529.         
  3530.         myErr = GotRequiredParams(theAppleEvent);
  3531.         
  3532.         /* now count */
  3533.     
  3534.         if (myErr == noErr) 
  3535.             myErr = MyCountProc(myClass,myDirObj.descriptorType, &myDirObj,&myCount);
  3536.         
  3537.         /* add result to reply */
  3538.     
  3539.         if (myErr == noErr) 
  3540.             if (reply->descriptorType != typeNull) 
  3541.                  myErr  = AEPutParamPtr(reply,
  3542.                                                                 keyDirectObject,
  3543.                                                                 typeLongInteger,
  3544.                                                                 (Ptr)&myCount,
  3545.                                                                 sizeof(myCount));
  3546.         if (myErr == noErr)       
  3547.             forgetErr  = AEDisposeDesc(&myDirObj);
  3548.         
  3549.         return(myErr);
  3550.         
  3551.     }    /* HandleNumberOfElements */
  3552.  
  3553. /** -----------------------------------------------------------------------
  3554.         Name:             HandleShowSelection
  3555.         Purpose:        Handles the Make Selection Visible AppleEvent.
  3556.      -----------------------------------------------------------------------**/
  3557.  
  3558. pascal OSErr HandleShowSelection(const AppleEvent *theAppleEvent,
  3559.                                                              AppleEvent       *reply,
  3560.                                                              long             handlerRefCon)
  3561.   {
  3562. #pragma unused (reply,handlerRefCon)
  3563.     
  3564.         OSErr       myErr;
  3565.         OSErr       ignoreErr;
  3566.         AEDesc      myDirObj;
  3567.         AEDesc      newDesc;
  3568.         AEDesc      tokenDesc;
  3569.         Size        actSize;
  3570.         WindowToken theWindowToken;
  3571.         DPtr        theDocument;
  3572.         TEHandle    theHTE;
  3573.         
  3574.         myErr      = errAEEventNotHandled;
  3575.         myDirObj.dataHandle  = nil;
  3576.         tokenDesc.dataHandle = nil;
  3577.         
  3578.         /*
  3579.             pick up direct object, i.e. the window in which to show the selection
  3580.         */
  3581.             
  3582.         myErr  = AEGetParamDesc(theAppleEvent,
  3583.                                                         keyDirectObject,
  3584.                                                         typeWildCard,
  3585.                                                         &myDirObj);
  3586.                 
  3587.         /*
  3588.             missing any parameters?
  3589.         */
  3590.         
  3591.         myErr = GotRequiredParams(theAppleEvent);
  3592.         
  3593.         /*
  3594.             convert object to WindowToken which we understand
  3595.         */
  3596.         myErr = AEResolve(&myDirObj, kAEIDoMinimum, &tokenDesc);
  3597.         
  3598.         if (myErr == noErr)
  3599.             if (tokenDesc.descriptorType==typeMyWndw)
  3600.                 {
  3601.                     if (AECoerceDesc(&myDirObj, typeMyWndw, &newDesc) == noErr) 
  3602.                         {
  3603.                             GetRawDataFromDescriptor(&newDesc,
  3604.                                                                              (Ptr)&theWindowToken,
  3605.                                                                              sizeof(theWindowToken),
  3606.                                                                              &actSize);
  3607.         
  3608.                             ignoreErr = AEDisposeDesc(&newDesc);
  3609.                             
  3610.                             if (myErr==noErr) 
  3611.                                 if (theWindowToken)                                                          
  3612.                                     ShowSelect(DPtrFromWindowPtr(theWindowToken));
  3613.                                 else
  3614.                                     myErr = errAEIllegalIndex;
  3615.                         }
  3616.                 }
  3617.             else
  3618.                 if (tokenDesc.descriptorType==typeMyText)
  3619.                     {
  3620.                         myErr = SetSelectionOfAppleEventObject(keyDirectObject,
  3621.                                                                                           theAppleEvent,
  3622.                                                                                            &theDocument,
  3623.                                                                                           &theHTE);
  3624.                         if (theDocument)
  3625.                           ShowSelect(theDocument);
  3626.                         else
  3627.                             myErr = errAEIllegalIndex;
  3628.                     }
  3629.                 else
  3630.                     myErr = errAEEventNotHandled;
  3631.                     
  3632.         if (myDirObj.dataHandle)
  3633.             ignoreErr = AEDisposeDesc(&myDirObj);
  3634.         
  3635.         if (tokenDesc.dataHandle)
  3636.             ignoreErr = AEDisposeDesc(&tokenDesc);
  3637.             
  3638.         return(myErr);
  3639.         
  3640.     }    /* HandleShowSelection */
  3641.  
  3642. pascal OSErr HandleStartRecording(const AppleEvent *theAppleEvent,
  3643.                                                               AppleEvent *reply,
  3644.                                                               long       handlerRefCon)        
  3645.     {
  3646. #pragma unused (reply,handlerRefCon)
  3647.  
  3648.         OSErr myErr;
  3649.  
  3650.       gBigBrother++;
  3651.     
  3652.         myErr = GotRequiredParams(theAppleEvent);
  3653.  
  3654.         return(myErr);
  3655.         
  3656.     }    /* HandleStartRecording */
  3657.  
  3658. pascal OSErr HandleStopRecording(const AppleEvent *theAppleEvent,
  3659.                                                              AppleEvent *reply,
  3660.                                                                  long handlerRefCon)        
  3661.     {
  3662. #pragma unused (theAppleEvent,reply,handlerRefCon)
  3663.     
  3664.         gBigBrother--;
  3665.         return(noErr);
  3666.     }    /* HandleStopRecording */
  3667.  
  3668.  
  3669. #pragma segment AECommandIssuers
  3670.  
  3671. /*******************************************************************************/
  3672. /* 
  3673.         Start of section involved in building and sending AppleEvent Objects as/with
  3674.         commands
  3675.  */
  3676.  
  3677. /*
  3678.     Make an AEDesc that describes the selection in the window and text edit
  3679.     record supplied
  3680. */
  3681.  
  3682. pascal OSErr MakeWindowObj(WindowPtr theWindow,
  3683.                                                    AEDesc    *dMyDoc)
  3684.     {
  3685.             OSErr    myErr;
  3686.             AEDesc   dNull;
  3687.             AEDesc   dDocIndex;
  3688.             short    winIndex;
  3689.             
  3690.             // AEDesc   dDocName;
  3691.             // Str255   windowName;
  3692.             
  3693.             //  Changed from name to index for better playback
  3694.             //  Needed as new windows now have incremental names
  3695.             //    GetWTitle(theWindow, windowName);
  3696.             //  myErr = AECreateDesc(typeChar,(Ptr)&windowName[1], windowName[0], &dDocName);
  3697.             //  CreateObjSpecifier was formName too…
  3698.             
  3699.             myErr = noErr;
  3700.             
  3701.             winIndex = IndexFromWindowPtr(theWindow);
  3702.             
  3703.             if (winIndex==0)
  3704.                 myErr = errAEIllegalIndex;
  3705.             
  3706.             if (myErr==noErr)
  3707.                 myErr = CreateOffsetDescriptor(winIndex, &dDocIndex);
  3708.             
  3709.             if (myErr==noErr) 
  3710.                 myErr = AECreateDesc(typeNull, nil , 0, &dNull);
  3711.             
  3712.             if (myErr==noErr) 
  3713.                 myErr = CreateObjSpecifier(cWindow, &dNull, formAbsolutePosition, &dDocIndex, true, dMyDoc);
  3714.             
  3715.             return(myErr);
  3716.             
  3717.     } /*MakeWindowObj*/
  3718.     
  3719. pascal OSErr MakeTextObj(WindowPtr theWindow,
  3720.                                                  short     selStart,
  3721.                                                  short     selEnd,
  3722.                                                  AEDesc    *selTextObj)
  3723.     {
  3724.         OSErr    myErr;
  3725.         OSErr    ignoreErr;
  3726.         AEDesc   dMyDoc;
  3727.         AEDesc   startOfs;
  3728.         AEDesc   endOfs;
  3729.         AEDesc   startObj;
  3730.         AEDesc   endObj;
  3731.         AEDesc   rangeDesc;
  3732.         long     startChar;
  3733.         long     endChar;
  3734.         Boolean  spotFlag;
  3735.             
  3736.         myErr = noErr;
  3737.         
  3738.         if (theWindow==nil) 
  3739.             return(noErr);
  3740.             
  3741.         selTextObj->dataHandle = nil;
  3742.         dMyDoc.dataHandle      = nil;
  3743.         startObj.dataHandle    = nil;
  3744.         endObj.dataHandle      = nil;
  3745.         
  3746.         /* 
  3747.             make the window object 
  3748.         */
  3749.         
  3750.         myErr = MakeWindowObj(theWindow, &dMyDoc);
  3751.             
  3752.         if (myErr==noErr)
  3753.             {
  3754.                 /* get the start and end of selection */
  3755.                 
  3756.                 startChar = selStart+1;    /* start counting obj's from 1, not 0 */
  3757.                 endChar   = selEnd;
  3758.                 spotFlag  = (selStart == selEnd);
  3759.                     
  3760.                 myErr = CreateOffsetDescriptor(startChar, &startOfs);
  3761.                             
  3762.                 if (myErr==noErr)
  3763.                     if (spotFlag)
  3764.                         myErr = CreateObjSpecifier(cSpot,
  3765.                                                                              &dMyDoc,
  3766.                                                                              formAbsolutePosition, 
  3767.                                                                              &startOfs, 
  3768.                                                                              true, 
  3769.                                                                              selTextObj);
  3770.                     else
  3771.                         {
  3772.                             /* not a spot - must represent as range */
  3773.                             /* make obj for start char */
  3774.                             
  3775.                             myErr = CreateObjSpecifier(cChar,
  3776.                                                        &dMyDoc,
  3777.                                                                                  formAbsolutePosition,
  3778.                                                                                  &startOfs,
  3779.                                                                                  false,
  3780.                                                                                  &startObj);
  3781.                             
  3782.                             if (myErr==noErr) 
  3783.                                 myErr = CreateOffsetDescriptor(endChar, &endOfs);
  3784.                             
  3785.                             if (myErr==noErr) 
  3786.                                 myErr = CreateObjSpecifier(cChar,
  3787.                                                                                      &dMyDoc,
  3788.                                                                                      formAbsolutePosition,
  3789.                                                                                      &endOfs,
  3790.                                                                                      false,
  3791.                                                                                      &endObj);
  3792.                             
  3793.                             if (myErr==noErr) 
  3794.                                 myErr = CreateRangeDescriptor(&startObj,
  3795.                                                                                             &endObj,
  3796.                                                                                             false,
  3797.                                                                                             &rangeDesc);
  3798.                             
  3799.                             if (myErr==noErr) 
  3800.                                 myErr = CreateObjSpecifier(cChar,
  3801.                                                                                      &dMyDoc,
  3802.                                                                                      formRange,
  3803.                                                                                      &rangeDesc,
  3804.                                                                                      true,
  3805.                                                                                      selTextObj);
  3806.                                                                                      
  3807.                             if (startObj.dataHandle)
  3808.                               ignoreErr = AEDisposeDesc(&startObj);
  3809.                                 
  3810.                             if (startOfs.dataHandle)
  3811.                               ignoreErr = AEDisposeDesc(&startOfs);
  3812.                                 
  3813.                             if (endObj.dataHandle)
  3814.                               ignoreErr = AEDisposeDesc(&endObj);
  3815.                                 
  3816.                             if (endOfs.dataHandle)
  3817.                               ignoreErr = AEDisposeDesc(&endOfs);
  3818.                         }
  3819.             }
  3820.             
  3821.         return(myErr);
  3822.     }
  3823.     
  3824. pascal OSErr MakeSelectedTextObj(WindowPtr theWindow,
  3825.                                                                  TEHandle  theTextEditHandle,
  3826.                                                                  AEDesc    *selTextObj)
  3827.     {
  3828.         return( MakeTextObj(theWindow,
  3829.                                                 (**theTextEditHandle).selStart,
  3830.                                                 (**theTextEditHandle).selEnd,
  3831.                                               selTextObj));
  3832.                                                 
  3833.     }    /* MakeSelectedTextObj */
  3834.  
  3835.  
  3836. /** -----------------------------------------------------------------------
  3837.         Name:             MakeMenuObj
  3838.         Purpose:        Creates a typeObjSpecifier for a named menu.
  3839.      -----------------------------------------------------------------------**/
  3840.  
  3841. pascal OSErr MakeMenuObj(Str255 theName, AEDesc *resultingObj)
  3842.     {
  3843.         AEDesc newDesc;
  3844.         AEDesc dNull;
  3845.         OSErr  theErr;
  3846.         
  3847.         theErr  = AECreateDesc(typeChar,
  3848.                                                      (Ptr)&theName[1],
  3849.                                                      theName[0],
  3850.                                                      &newDesc);
  3851.         if (theErr==noErr)
  3852.             {
  3853.                 theErr = AECreateDesc(typeNull, nil , 0, &dNull);
  3854.                 
  3855.                 theErr = CreateObjSpecifier(cMenu,
  3856.                                                                         &dNull,
  3857.                                                                         formName,
  3858.                                                                         &newDesc,
  3859.                                                                         true,
  3860.                                                                         resultingObj);
  3861.             }
  3862.             
  3863.         return(theErr);
  3864.         
  3865.     } /* MakeMenuObj */
  3866.     
  3867. /** -----------------------------------------------------------------------
  3868.         Name:             MakeMenuItemObj
  3869.         Purpose:        Creates a typeObjSpecifier for a named menu.
  3870.      -----------------------------------------------------------------------**/
  3871.  
  3872. pascal OSErr MakeMenuItemObj(Str255 theName, short theItem, AEDesc *resultingObj)
  3873.     {
  3874.         AEDesc menuDesc;
  3875.         AEDesc dataDesc;
  3876.         
  3877.         OSErr  theErr;
  3878.         
  3879.         theErr  = MakeMenuObj(theName, &menuDesc);
  3880.         
  3881.         if (theErr==noErr)
  3882.             {
  3883.                 theErr = CreateOffsetDescriptor(theItem, &dataDesc);
  3884.                 
  3885.                 theErr = CreateObjSpecifier(cMenu,
  3886.                                                                         &menuDesc,
  3887.                                                                         formAbsolutePosition,
  3888.                                                                         &dataDesc,
  3889.                                                                         true,
  3890.                                                                         resultingObj);
  3891.             }
  3892.             
  3893.         return(theErr);
  3894.     } /* MakeMenuItemObj */
  3895.     
  3896. pascal OSErr MakeClassObj(DescType theClass, AEDesc *myClassObj)
  3897.     {  
  3898.         return(AECreateDesc(typeType,
  3899.                                                      (Ptr)&theClass,
  3900.                                                      sizeof(DescType),
  3901.                                                      myClassObj));
  3902.     } /* MakeClassObj */
  3903.     
  3904. enum editCommandType {
  3905. editCutCommand   = 1,
  3906. editCopyCommand  = 2,
  3907. editPasteCommand = 3,
  3908. editClearCommand = 4
  3909. };
  3910.  
  3911. typedef enum editCommandType editCommandType;
  3912.  
  3913. pascal void DoEditCommand(DPtr theDocument,editCommandType whatCommand)
  3914.     {
  3915.       OSErr         err;
  3916.       OSErr         forgetErr;
  3917.         AEAddressDesc ourAddress;
  3918.         AppleEvent    editCommandEvent;
  3919.         AppleEvent    ignoreReply;
  3920.         AEDesc        ourTextSelObj;
  3921.         AEEventID     theEventID;
  3922.         AEEventClass  theEventClass;
  3923.  
  3924.         /*
  3925.                 Initialise
  3926.         */
  3927.  
  3928.         ourAddress.dataHandle             = nil;
  3929.         ourTextSelObj.dataHandle         = nil;
  3930.         editCommandEvent.dataHandle = nil;
  3931.         ignoreReply.dataHandle             = nil;
  3932.         
  3933.         err = MakeSelfAddress(&ourAddress);
  3934.         
  3935.         /*
  3936.             Build an object to represent the current document's selection
  3937.         */
  3938.         err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &ourTextSelObj);
  3939.         
  3940.         if (err==noErr)
  3941.           {
  3942.                 switch (whatCommand) {
  3943.                     case  editCutCommand         : theEventID    = kAECut;
  3944.                                                                         theEventClass = kAEMiscStandards;
  3945.                                                                         break;
  3946.                     case  editCopyCommand     : theEventID    = kAECopy;
  3947.                                                                         theEventClass = kAEMiscStandards;
  3948.                                                                         break;
  3949.                     case  editPasteCommand     : theEventID    = kAEPaste;
  3950.                                                                         theEventClass = kAEMiscStandards;
  3951.                                                                         break;
  3952.                     case  editClearCommand     : theEventID    = kAEDelete;
  3953.                                                                         theEventClass = kAECoreSuite;
  3954.                                                                         break;
  3955.                 }
  3956.                     
  3957.                 err = AECreateAppleEvent( theEventClass, theEventID, &ourAddress, 0, 0, &editCommandEvent);    
  3958.  
  3959.                 /* add parameter */    
  3960.                 if (err==noErr) 
  3961.                     err = AEPutParamDesc(&editCommandEvent, keyDirectObject, &ourTextSelObj);
  3962.                     
  3963.                 /*and now Send the message*/
  3964.                 if (err==noErr)
  3965.                     err = AESend(&editCommandEvent,&ignoreReply,kAENoReply,kAEHighPriority,10000,nil, nil);
  3966.             }              
  3967.             
  3968.         /*
  3969.             Clean up
  3970.         */
  3971.         if (ourAddress.dataHandle) 
  3972.             forgetErr = AEDisposeDesc(&ourAddress);
  3973.         
  3974.         if (editCommandEvent.dataHandle) 
  3975.             forgetErr = AEDisposeDesc(&editCommandEvent);
  3976.         
  3977.         if (ignoreReply.dataHandle) 
  3978.             forgetErr = AEDisposeDesc(&ignoreReply);
  3979.             
  3980.         if (ourTextSelObj.dataHandle) 
  3981.             forgetErr = AEDisposeDesc(&ourTextSelObj);
  3982.             
  3983.     } /*DoEditCommand*/
  3984.     
  3985. pascal void IssueCutCommand(DPtr theDocument)
  3986.     {            
  3987.         DoEditCommand(theDocument, editCutCommand);
  3988.     } 
  3989.     
  3990. pascal void IssueCopyCommand(DPtr theDocument)
  3991.     {
  3992.         DoEditCommand(theDocument, editCopyCommand);
  3993.     }
  3994.     
  3995. pascal void IssuePasteCommand(DPtr theDocument)
  3996.     {
  3997.         DoEditCommand(theDocument, editPasteCommand);    
  3998.     }
  3999.     
  4000. pascal void IssueClearCommand(DPtr theDocument)
  4001.     {
  4002.         DoEditCommand(theDocument, editClearCommand);    
  4003.     }
  4004.     
  4005. pascal void IssueFontCommand(DPtr theDocument, short theItem)
  4006.     {
  4007.        Str255         name;
  4008.          AEDesc           strDesc;
  4009.          AEAddressDesc  theAddress;
  4010.          OSErr            err;
  4011.          AEDesc         selTextObj;
  4012.             
  4013.         err = MakeSelfAddress(&theAddress);
  4014.         
  4015.         err = MakeSelectedTextObj(theDocument->theWindow,
  4016.                                                             theDocument->theText,
  4017.                                                             &selTextObj);
  4018.         
  4019.         GetItem(myMenus[fontM], theItem, name);
  4020.         
  4021.         if (err==noErr)
  4022.             err  = AECreateDesc(typeChar,
  4023.                                                     (Ptr)&name[1],
  4024.                                                     name[0],
  4025.                                                     &strDesc);
  4026.         
  4027.         if (err==noErr)
  4028.             err  = SendAESetObjProp(&selTextObj, 
  4029.                                                             pFont,
  4030.                                                             &strDesc,
  4031.                                                             &theAddress);                                                            
  4032.     }
  4033.     
  4034. /*
  4035.     Window property routines
  4036. */
  4037.  
  4038. pascal void IssueZoomCommand(WindowPtr whichWindow, short whichPart)
  4039.     {
  4040.       Boolean       zoomBool;
  4041.         AEDesc        zoomDesc;
  4042.         AEAddressDesc selfAddr;
  4043.         AEDesc        frontWinObj;
  4044.         OSErr         err;
  4045.     
  4046.         err = MakeSelfAddress(&selfAddr);
  4047.         
  4048.         err = MakeWindowObj(whichWindow, &frontWinObj);
  4049.         
  4050.         zoomBool = (whichPart==inZoomOut);
  4051.     
  4052.         err = AECreateDesc(typeBoolean,
  4053.                                              (Ptr)&zoomBool,
  4054.                                              sizeof(zoomBool),
  4055.                                              &zoomDesc);
  4056.                                                 
  4057.         err = SendAESetObjProp(&frontWinObj, 
  4058.                                                      pIsZoomed,
  4059.                                                      &zoomDesc,
  4060.                                                      &selfAddr);                                                            
  4061.     } /* IssueZoomCommand */
  4062.     
  4063. pascal void IssueCloseCommand(WindowPtr whichWindow)
  4064.     {
  4065.         AEAddressDesc  selfAddr;
  4066.         AEDesc         frontWinObj;
  4067.         OSErr          err;
  4068.         OSErr          ignoreErr;
  4069.         AppleEvent     closeCommandEvent;
  4070.         AppleEvent     ignoreReply;
  4071.     
  4072.         frontWinObj.dataHandle = nil;
  4073.         
  4074.         err = MakeSelfAddress(&selfAddr);
  4075.         
  4076.         err = MakeWindowObj(whichWindow, &frontWinObj);
  4077.                                                             
  4078.         err = AECreateAppleEvent( kAECoreSuite, kAEClose, &selfAddr, 0, 0, &closeCommandEvent) ;                
  4079.         
  4080.         /* add parameter - the window to close */    
  4081.         if (err==noErr) 
  4082.             err = AEPutParamDesc(&closeCommandEvent, keyDirectObject, &frontWinObj);
  4083.             
  4084.         if (err==noErr) 
  4085.             err = AESend(&closeCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAEHighPriority,10000,nil, nil);
  4086.         
  4087.         if (closeCommandEvent.dataHandle) 
  4088.             ignoreErr = AEDisposeDesc(&closeCommandEvent);
  4089.         
  4090.         if (frontWinObj.dataHandle) 
  4091.             ignoreErr = AEDisposeDesc(&frontWinObj);
  4092.             
  4093.         if (selfAddr.dataHandle) 
  4094.             ignoreErr = AEDisposeDesc(&selfAddr);
  4095.             
  4096.     } /* IssueCloseCommand */
  4097.     
  4098. pascal void IssueSizeWindow(WindowPtr whichWindow, short newHSize, short newVSize)
  4099.     {
  4100.       Rect          sizeRect;
  4101.         Rect          contentRect;
  4102.         short         edgeSize;
  4103.         AEDesc        sizeDesc;
  4104.         AEAddressDesc selfAddr;
  4105.         AEDesc        frontWinObj;
  4106.         OSErr         err;
  4107.     
  4108.         sizeRect    = (**(((WindowPeek)whichWindow)->strucRgn)).rgnBBox;
  4109.         contentRect = (**(((WindowPeek)whichWindow)->contRgn)).rgnBBox;
  4110.         
  4111.         edgeSize = sizeRect.right-sizeRect.left-(contentRect.right-contentRect.left);
  4112.         sizeRect.right = sizeRect.left+newHSize+edgeSize;
  4113.         
  4114.         edgeSize = sizeRect.bottom-sizeRect.top-(contentRect.bottom-contentRect.top);
  4115.         sizeRect.bottom = sizeRect.top+newVSize+edgeSize;
  4116.         
  4117.         err = MakeSelfAddress(&selfAddr);
  4118.         
  4119.         err = MakeWindowObj(whichWindow, &frontWinObj);
  4120.         
  4121.         if (err==noErr)
  4122.             err = AECreateDesc(typeQDRectangle,
  4123.                                                  (Ptr)&sizeRect,
  4124.                                                  sizeof(sizeRect),
  4125.                                                  &sizeDesc);
  4126.         
  4127.         if (err==noErr)
  4128.             err  = SendAESetObjProp(&frontWinObj, 
  4129.                                                             pBounds,
  4130.                                                             &sizeDesc,
  4131.                                                             &selfAddr);                                                            
  4132.     } /*IssueSizeWindow*/
  4133.     
  4134. pascal void IssueMoveWindow(WindowPtr whichWindow, Rect sizeRect)
  4135.     {
  4136.         AEDesc        sizeDesc;
  4137.         AEAddressDesc selfAddr;
  4138.         AEDesc        frontWinObj;
  4139.         OSErr         err;
  4140.     
  4141.         err = MakeSelfAddress(&selfAddr);
  4142.         
  4143.         err = MakeWindowObj(whichWindow, &frontWinObj);
  4144.             
  4145.         if (err==noErr)
  4146.             err = AECreateDesc(typeQDRectangle,
  4147.                                                  (Ptr)&sizeRect,
  4148.                                                  sizeof(sizeRect),
  4149.                                                  &sizeDesc);
  4150.         
  4151.         if (err==noErr)        
  4152.             err = SendAESetObjProp(&frontWinObj, 
  4153.                                                          pBounds,
  4154.                                                          &sizeDesc,
  4155.                                                          &selfAddr);                                                            
  4156.     } /*IssueMoveWindow*/
  4157.  
  4158. pascal void IssuePageSetupWindow(WindowPtr whichWindow, TPrint thePageSetup)
  4159.     {
  4160.         AEDesc        sizeDesc;
  4161.         AEAddressDesc selfAddr;
  4162.         AEDesc        frontWinObj;
  4163.         OSErr         err;
  4164.     
  4165.         err = MakeSelfAddress(&selfAddr);
  4166.         
  4167.         err = MakeWindowObj(whichWindow, &frontWinObj);
  4168.         
  4169.         if (err==noErr)
  4170.             err = AECreateDesc(typeTPrint,
  4171.                                                  (Ptr)&thePageSetup,
  4172.                                                  sizeof(thePageSetup),
  4173.                                                  &sizeDesc);
  4174.                                                  
  4175.         if (err==noErr)
  4176.             err = SendAESetObjProp(&frontWinObj, 
  4177.                                                          pPageSetup,
  4178.                                                          &sizeDesc,
  4179.                                                          &selfAddr);                                                            
  4180.                                                      
  4181.     } /*IssuePageSetupWindow*/
  4182.     
  4183. pascal void IssueShowBorders(WindowPtr whichWindow, Boolean showBorders)
  4184.     {
  4185.         AEDesc        sizeDesc;
  4186.         AEAddressDesc selfAddr;
  4187.         AEDesc        frontWinObj;
  4188.         OSErr         err;
  4189.     
  4190.         err = MakeSelfAddress(&selfAddr);
  4191.         
  4192.         err = MakeWindowObj(whichWindow, &frontWinObj);
  4193.         
  4194.         if (err==noErr)
  4195.             err = AECreateDesc(typeBoolean,
  4196.                                                  (Ptr)&showBorders,
  4197.                                                  sizeof(showBorders),
  4198.                                                  &sizeDesc);
  4199.         
  4200.         if (err==noErr)
  4201.             err = SendAESetObjProp(&frontWinObj, 
  4202.                                                          pShowBorders,
  4203.                                                          &sizeDesc,
  4204.                                                          &selfAddr);                                                            
  4205.     } /*IssueShowBorders*/
  4206.     
  4207. pascal void IssuePrintWindow(WindowPtr whichWindow)
  4208.     {
  4209.         AEAddressDesc selfAddr;
  4210.         AEDesc        frontWinObj;
  4211.         OSErr         err;
  4212.         OSErr         ignoreErr;
  4213.         AppleEvent    printCommandEvent;
  4214.         AppleEvent    ignoreReply;
  4215.     
  4216.         err = MakeSelfAddress(&selfAddr);
  4217.         
  4218.         err = MakeWindowObj(whichWindow, &frontWinObj);
  4219.                                                             
  4220.         err = AECreateAppleEvent(kCoreEventClass, kAEPrintDocuments, &selfAddr, 0, 0, &printCommandEvent) ;                
  4221.  
  4222.         /* 
  4223.             add parameter - the window to print
  4224.         */    
  4225.  
  4226.         if (err==noErr) 
  4227.             err = AEPutParamDesc(&printCommandEvent, keyDirectObject, &frontWinObj);
  4228.             
  4229.         if (err==noErr) 
  4230.             err = AESend(&printCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAEHighPriority,10000,nil, nil);
  4231.     
  4232.       if (printCommandEvent.dataHandle)
  4233.             ignoreErr = AEDisposeDesc(&printCommandEvent);
  4234.         
  4235.         if (frontWinObj.dataHandle) 
  4236.             ignoreErr = AEDisposeDesc(&frontWinObj);
  4237.             
  4238.         if (selfAddr.dataHandle) 
  4239.             ignoreErr = AEDisposeDesc(&selfAddr);
  4240.             
  4241.     } /*IssuePrintWindow*/
  4242.     
  4243. pascal OSErr IssueAEOpenDoc(FSSpec myFSSpec)
  4244. /* send OpenDocs AppleEvent to myself, with a one-element list
  4245.   containing the given file spec
  4246.  
  4247.   NOTES : the core AEOpenDocs event is defined as taking a list of
  4248.           aliases (not file specs) as its direct parameter.  However,
  4249.             we can send the file spec instead and depend on AppleEvents'
  4250.             automatic coercion.  In fact, we don't really even have to put 
  4251.             in a list; AppleEvents will coerce a descriptor into a 1-element
  4252.             list if called for.  In this routine, though, we'll make the
  4253.             list for demonstration purposes.
  4254. */
  4255.  
  4256.  {
  4257.          AppleEvent    myAppleEvent;
  4258.         AppleEvent    defReply;
  4259.         AEDescList    docList;
  4260.         AEAddressDesc selfAddr;
  4261.         OSErr         myErr;
  4262.         OSErr         ignoreErr;
  4263.         
  4264.         myAppleEvent.dataHandle = nil;
  4265.         docList.dataHandle  = nil;
  4266.         selfAddr.dataHandle = nil;
  4267.         defReply.dataHandle = nil;
  4268.             
  4269.         /*
  4270.             Create empty list and add one file spec
  4271.         */
  4272.         myErr = AECreateList(nil,0,false, &docList);
  4273.         
  4274.         if (myErr==noErr) 
  4275.             myErr = AEPutPtr(&docList,1,typeFSS,(Ptr)&myFSSpec,sizeof(myFSSpec));
  4276.             
  4277.         /*
  4278.             Create a self address to send it to
  4279.         */
  4280.         if (myErr==noErr) 
  4281.             myErr = MakeSelfAddress(&selfAddr);
  4282.             
  4283.         if (myErr==noErr) 
  4284.             myErr = AECreateAppleEvent(kCoreEventClass,
  4285.                                                                  kAEOpenDocuments,
  4286.                                                                  &selfAddr,
  4287.                                                                  kAutoGenerateReturnID,
  4288.                                                                  kAnyTransactionID,
  4289.                                                                  &myAppleEvent);
  4290.     
  4291.         /* 
  4292.             Put Params into our event and send it
  4293.         */
  4294.         if (myErr == noErr) 
  4295.             myErr = AEPutParamDesc(&myAppleEvent,
  4296.                                                          keyDirectObject,
  4297.                                                          &docList);
  4298.     
  4299.         myErr = AESend(&myAppleEvent,
  4300.                                      &defReply,
  4301.                                      kAENoReply+kAEAlwaysInteract,
  4302.                                      kAENormalPriority,
  4303.                                      kAEDefaultTimeout,
  4304.                                      nil,
  4305.                                      nil);
  4306.             
  4307.         if (selfAddr.dataHandle) 
  4308.             ignoreErr = AEDisposeDesc(&selfAddr);
  4309.             
  4310.         if (myAppleEvent.dataHandle) 
  4311.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4312.             
  4313.         if (docList.dataHandle) 
  4314.             ignoreErr = AEDisposeDesc(&docList);
  4315.             
  4316.         return(myErr);
  4317.         
  4318.     }    /* IssueAEOpenDoc */
  4319.  
  4320. pascal void IssueAENewWindow(void)
  4321. /* 
  4322.     send the New Element event to myself with a null container
  4323. */
  4324.     {
  4325.       AppleEvent    myAppleEvent;
  4326.         AppleEvent    defReply;
  4327.         AEAddressDesc selfAddr;
  4328.         OSErr         myErr;
  4329.         OSErr         ignoreErr;
  4330.         DescType      elemClass;
  4331.         
  4332.         myAppleEvent.dataHandle = nil;
  4333.         
  4334.         /*
  4335.             Create the address of us
  4336.         */
  4337.         
  4338.         myErr = MakeSelfAddress(&selfAddr);
  4339.         
  4340.         /*
  4341.             create event 
  4342.         */
  4343.         
  4344.         myErr = AECreateAppleEvent(kAECoreSuite,
  4345.                                                              kAECreateElement,
  4346.                                                              &selfAddr,
  4347.                                                              kAutoGenerateReturnID,
  4348.                                                              kAnyTransactionID,
  4349.                                                              &myAppleEvent);
  4350.         
  4351.         /*
  4352.             attach desired class of new element
  4353.         */
  4354.         
  4355.         elemClass = cWindow;
  4356.         
  4357.         if (myErr == noErr) 
  4358.             myErr = AEPutParamPtr(&myAppleEvent,
  4359.                                                       keyAEObjectClass,
  4360.                                                         typeType,
  4361.                                                         (Ptr)&elemClass,
  4362.                                                         sizeof(elemClass));
  4363.             
  4364.         /*
  4365.             send the event 
  4366.         */
  4367.         
  4368.         if (myErr == noErr) 
  4369.             myErr = AESend(&myAppleEvent,
  4370.                                          &defReply,
  4371.                                          kAENoReply+kAENeverInteract,
  4372.                                          kAENormalPriority,
  4373.                                          kAEDefaultTimeout,
  4374.                                          nil,
  4375.                                          nil);
  4376.         /*
  4377.             Clean up - reply never created so don't throw away
  4378.         */
  4379.         if (selfAddr.dataHandle) 
  4380.             ignoreErr = AEDisposeDesc(&selfAddr);
  4381.             
  4382.         if (myAppleEvent.dataHandle) 
  4383.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4384.                     
  4385.     }    /* IssueAENewWindow */
  4386.  
  4387. pascal OSErr IssueSaveCommand(WindowPtr theWindow,
  4388.                               FSSpecPtr where)
  4389. /*
  4390.     send an AppleEvent Save Event to myself
  4391. */
  4392.  
  4393. {
  4394.     AEDesc        windowObj;
  4395.     AppleEvent    myAppleEvent;
  4396.     AppleEvent    defReply;
  4397.     OSErr         myErr;
  4398.     OSErr         ignoreErr;
  4399.     AEAddressDesc selfAddr;
  4400.         
  4401.     windowObj.dataHandle = nil;
  4402.     myAppleEvent.dataHandle = nil;
  4403.     
  4404.     myErr = MakeWindowObj(theWindow, &windowObj);
  4405.             
  4406.     if (myErr==noErr) 
  4407.         myErr = MakeSelfAddress(&selfAddr);
  4408.         
  4409.   /*
  4410.         Build event
  4411.     */
  4412.     
  4413.   if (myErr == noErr) 
  4414.         myErr = AECreateAppleEvent(kAECoreSuite,
  4415.                                                              kAESave,
  4416.                                                              &selfAddr,
  4417.                                                              kAutoGenerateReturnID,
  4418.                                                              kAnyTransactionID,
  4419.                                                              &myAppleEvent);
  4420.       
  4421.   /*
  4422.         say which window
  4423.     */
  4424.     
  4425.   if (myErr==noErr) 
  4426.         myErr = AEPutParamDesc(&myAppleEvent,
  4427.                                                      keyDirectObject,
  4428.                                                      &windowObj);
  4429.   
  4430.   /*
  4431.         add optional file param if we need to
  4432.     */
  4433.     
  4434.   if (where) 
  4435.         if (myErr==noErr) 
  4436.             myErr = AEPutParamPtr(&myAppleEvent,
  4437.                                                         keyAEDestination,
  4438.                                                         typeFSS,
  4439.                                                         (Ptr)where,
  4440.                                                         sizeof(FSSpec));
  4441.         
  4442.   /*
  4443.         send the event
  4444.     */
  4445.   if (myErr==noErr) 
  4446.         myErr  = AESend(&myAppleEvent,
  4447.                                         &defReply,
  4448.                                         kAENoReply+kAENeverInteract,
  4449.                                         kAENormalPriority,
  4450.                                         kAEDefaultTimeout,
  4451.                                         nil,
  4452.                                         nil);
  4453.       
  4454.     if (selfAddr.dataHandle) 
  4455.         ignoreErr = AEDisposeDesc(&selfAddr);
  4456.       
  4457.     if (windowObj.dataHandle) 
  4458.         ignoreErr = AEDisposeDesc(&windowObj);
  4459.         
  4460.     if (myAppleEvent.dataHandle) 
  4461.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  4462.         
  4463.     return(myErr);
  4464. }    /* IssueSaveCommand */
  4465.  
  4466. pascal void IssueSelectWindowCommand(WindowPtr theWindow, WindowPtr oldFrontWindow)
  4467. /*
  4468.     send an AppleEvent Move Event to ourself to select the chosen window
  4469.     i.e. bring it to the front. This is the same as move before the front window.
  4470. */
  4471.  
  4472. {
  4473.     AEDesc        windowObj;
  4474.     AEDesc        fWinObj;
  4475.     AEDesc        theDestObject;
  4476.     AEDesc        theDestRecord;
  4477.     DescType      thePosn;
  4478.     AppleEvent    myAppleEvent;
  4479.     AppleEvent    defReply;
  4480.     OSErr         myErr;
  4481.     OSErr         ignoreErr;
  4482.     AEAddressDesc selfAddr;
  4483.         
  4484.     windowObj.dataHandle    = nil;
  4485.     myAppleEvent.dataHandle = nil;
  4486.     
  4487.     myErr = MakeWindowObj(theWindow, &windowObj);
  4488.             
  4489.     if (myErr==noErr) 
  4490.         myErr = MakeSelfAddress(&selfAddr);
  4491.         
  4492.   /*
  4493.         Build event
  4494.     */
  4495.     
  4496.   if (myErr == noErr) 
  4497.         myErr = AECreateAppleEvent(kAECoreSuite,
  4498.                                                              kAEMove,
  4499.                                                              &selfAddr,
  4500.                                                              kAutoGenerateReturnID,
  4501.                                                              kAnyTransactionID,
  4502.                                                              &myAppleEvent);
  4503.       
  4504.   /*
  4505.         say which window
  4506.     */
  4507.     
  4508.   if (myErr==noErr) 
  4509.         myErr = AEPutParamDesc(&myAppleEvent,
  4510.                                                      keyDirectObject,
  4511.                                                      &windowObj);
  4512.   
  4513.   /*
  4514.         add to where param - typeInsertionLoc
  4515.     */
  4516.     
  4517.     if (myErr==noErr)
  4518.         {
  4519.             // Build a record
  4520.             
  4521.             theDestRecord.dataHandle = nil;
  4522.             theDestObject.dataHandle = nil;
  4523.             fWinObj.dataHandle       = nil;
  4524.             
  4525.             myErr = AECreateList(nil, 0, true, &theDestRecord);
  4526.             
  4527.             if (myErr==noErr)
  4528.                 { // add the reference object - the current front window
  4529.  
  4530.                     myErr = MakeWindowObj(oldFrontWindow, &fWinObj);
  4531.                     
  4532.                     if (myErr==noErr)
  4533.                         myErr = AEPutKeyDesc(&theDestRecord,
  4534.                                                                  keyAEObject,
  4535.                                                                  &fWinObj);
  4536.                     
  4537.                     if (fWinObj.dataHandle)
  4538.                         ignoreErr = AEDisposeDesc(&fWinObj);
  4539.                 }
  4540.             
  4541.             // How to place it relative to the reference object
  4542.             thePosn = kAEBefore;
  4543.             
  4544.             if (myErr==noErr)
  4545.                 myErr = AEPutKeyPtr(&theDestRecord,
  4546.                                                       keyAEPosition,
  4547.                                                       typeEnumeration,
  4548.                                                       (Ptr)&thePosn,
  4549.                                                       sizeof(thePosn));
  4550.             
  4551.             if (myErr==noErr)
  4552.                 myErr = AECoerceDesc(&theDestRecord, typeInsertionLoc, &theDestObject);
  4553.             
  4554.             if (theDestRecord.dataHandle)
  4555.                 ignoreErr = AEDisposeDesc(&theDestRecord);
  4556.             
  4557.             if (myErr==noErr)
  4558.                 myErr = AEPutParamDesc(&myAppleEvent,
  4559.                                                              keyAEInsertHere,
  4560.                                                              &theDestObject);
  4561.                                                          
  4562.             if (theDestObject.dataHandle)
  4563.                 ignoreErr = AEDisposeDesc(&theDestObject);
  4564.         }
  4565.         
  4566.   /*
  4567.         send the event
  4568.     */
  4569.   if (myErr==noErr) 
  4570.         myErr  = AESend(&myAppleEvent,
  4571.                                         &defReply,
  4572.                                         kAENoReply+kAEDontExecute,
  4573.                                         kAENormalPriority,
  4574.                                         kAEDefaultTimeout,
  4575.                                         nil,
  4576.                                         nil);
  4577.       
  4578.     if (selfAddr.dataHandle) 
  4579.         ignoreErr = AEDisposeDesc(&selfAddr);
  4580.       
  4581.     if (windowObj.dataHandle) 
  4582.         ignoreErr = AEDisposeDesc(&windowObj);
  4583.         
  4584.     if (myAppleEvent.dataHandle) 
  4585.         ignoreErr = AEDisposeDesc(&myAppleEvent);
  4586.         
  4587. }    /* IssueSelectWindowCommand */
  4588.  
  4589. pascal OSErr IssueRevertCommand(WindowPtr theWindow)
  4590. /*
  4591.     send an AppleEvent Revert Event to myself
  4592. */
  4593.  
  4594.     {
  4595.         AEDesc        windowObj;
  4596.         AppleEvent    myAppleEvent;
  4597.         AppleEvent    defReply;
  4598.         OSErr         myErr;
  4599.         OSErr         ignoreErr;
  4600.         AEAddressDesc selfAddr;
  4601.         
  4602.         windowObj.dataHandle = nil;
  4603.         myAppleEvent.dataHandle = nil;
  4604.         
  4605.         myErr = MakeWindowObj(theWindow, &windowObj);
  4606.                     
  4607.         if (myErr==noErr) 
  4608.             myErr = MakeSelfAddress(&selfAddr);
  4609.             
  4610.         /*
  4611.             Build event
  4612.         */
  4613.         
  4614.         if (myErr == noErr) 
  4615.             myErr  = AECreateAppleEvent(kAEMiscStandards,
  4616.                                                                     kAERevert,
  4617.                                                                     &selfAddr,
  4618.                                                                     kAutoGenerateReturnID,
  4619.                                                                     kAnyTransactionID,
  4620.                                                                     &myAppleEvent);
  4621.         /*
  4622.             say which window
  4623.         */
  4624.         
  4625.         if (myErr == noErr) 
  4626.             myErr = AEPutParamDesc(&myAppleEvent,
  4627.                                                          keyDirectObject,
  4628.                                                          &windowObj);
  4629.         /*
  4630.             send the event
  4631.         */
  4632.         if (myErr==noErr) 
  4633.             myErr  = AESend(&myAppleEvent,
  4634.                                             &defReply,
  4635.                                             kAENoReply+kAENeverInteract,
  4636.                                             kAENormalPriority,
  4637.                                             kAEDefaultTimeout,
  4638.                                             nil,
  4639.                                             nil);
  4640.             
  4641.         if (windowObj.dataHandle) 
  4642.             ignoreErr = AEDisposeDesc(&windowObj);
  4643.             
  4644.         if (myAppleEvent.dataHandle) 
  4645.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4646.             
  4647.         if (selfAddr.dataHandle) 
  4648.             ignoreErr = AEDisposeDesc(&selfAddr);
  4649.             
  4650.         return(myErr);
  4651.     }    /* IssueRevertCommand */
  4652.  
  4653. /*
  4654.     Name : IssueQuitCommand
  4655.     Purpose : Sends self a Quit AppleEvent
  4656. */
  4657. pascal OSErr IssueQuitCommand(void)
  4658.     {
  4659.         AppleEvent    myAppleEvent;
  4660.         AppleEvent    defReply;
  4661.         OSErr         myErr;
  4662.         OSErr         ignoreErr;
  4663.         AEAddressDesc selfAddr;
  4664.         DescType      mySaveOpt;
  4665.         
  4666.         myAppleEvent.dataHandle = nil;
  4667.         selfAddr.dataHandle     = nil;
  4668.                             
  4669.         myErr = MakeSelfAddress(&selfAddr);
  4670.             
  4671.         /*
  4672.             Build event
  4673.         */
  4674.         
  4675.         if (myErr == noErr) 
  4676.             myErr  = AECreateAppleEvent(kCoreEventClass,
  4677.                                                                     kAEQuitApplication,
  4678.                                                                     &selfAddr,
  4679.                                                                     kAutoGenerateReturnID,
  4680.                                                                     kAnyTransactionID,
  4681.                                                                     &myAppleEvent);
  4682.         /*
  4683.             say which save option
  4684.         */
  4685.         
  4686.         mySaveOpt = kAEAsk;
  4687.         
  4688.         if (myErr == noErr) 
  4689.             myErr = AEPutParamPtr(&myAppleEvent,
  4690.                                                         keyAESaveOptions,
  4691.                                                         typeEnumerated,
  4692.                                                         (Ptr)&mySaveOpt,
  4693.                                                         sizeof(mySaveOpt));
  4694.         /*
  4695.             send the event
  4696.         */
  4697.         if (myErr==noErr) 
  4698.             myErr  = AESend(&myAppleEvent,
  4699.                                             &defReply,
  4700.                                             kAENoReply+kAEAlwaysInteract,
  4701.                                             kAENormalPriority,
  4702.                                             kAEDefaultTimeout,
  4703.                                             nil,
  4704.                                             nil);
  4705.                         
  4706.         if (myAppleEvent.dataHandle) 
  4707.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4708.             
  4709.         if (selfAddr.dataHandle) 
  4710.             ignoreErr = AEDisposeDesc(&selfAddr);
  4711.             
  4712.         return(myErr);
  4713.     }    /* IssueQuitCommand */
  4714.  
  4715. /*
  4716.      Name :IssueCreatePublisher
  4717.      Purpose :Interact with user to get Publisher info
  4718.                         and the IssueAECommand to Publish currect selection
  4719. */
  4720. pascal void IssueCreatePublisher(DPtr whichDoc)
  4721.     {
  4722.         AEAddressDesc selfAddr;
  4723.         AEDesc        selTextObj;
  4724.         OSErr         err;
  4725.         OSErr         ignoreErr;
  4726.         AppleEvent    publishCommandEvent;
  4727.         AppleEvent    ignoreReply;
  4728.     
  4729.       publishCommandEvent.dataHandle = nil;
  4730.         selfAddr.dataHandle = nil;
  4731.         selTextObj.dataHandle = nil;
  4732.         
  4733.         err = MakeSelfAddress(&selfAddr);
  4734.         
  4735.         if (err==noErr)
  4736.             err = MakeSelectedTextObj(whichDoc->theWindow, whichDoc->theText, &selTextObj);
  4737.                                                             
  4738.         err = AECreateAppleEvent( kAEMiscStandards,
  4739.                                   kAECreatePublisher,
  4740.                                                             &selfAddr,
  4741.                                                             0,
  4742.                                                             0,
  4743.                                                             &publishCommandEvent) ;                
  4744.  
  4745.         /* 
  4746.             add parameter - the text to publish
  4747.         */    
  4748.  
  4749.         if (err==noErr) 
  4750.             err = AEPutParamDesc(&publishCommandEvent, keyDirectObject, &selTextObj);
  4751.             
  4752.         if (err==noErr) 
  4753.             err = AESend(&publishCommandEvent,&ignoreReply,kAENoReply+kAEAlwaysInteract,kAEHighPriority,10000,nil, nil);
  4754.     
  4755.       if (publishCommandEvent.dataHandle)
  4756.             ignoreErr = AEDisposeDesc(&publishCommandEvent);
  4757.         
  4758.         if (selTextObj.dataHandle) 
  4759.             ignoreErr = AEDisposeDesc(&selTextObj);
  4760.             
  4761.         if (selfAddr.dataHandle) 
  4762.             ignoreErr = AEDisposeDesc(&selfAddr);
  4763.             
  4764.     } /*IssueCreatePublisher*/
  4765.     
  4766. #define kOK 1
  4767. #define kCancel 2
  4768. #define kOtherSize 4
  4769. #define kOutlineItem 5
  4770.  
  4771. pascal Boolean PoseSizeDialog(long *whatSize)
  4772.   {
  4773.       GrafPtr   savedPort;
  4774.     DialogPtr aDialog;
  4775.       Str255    aString;
  4776.       short     itemHit;
  4777.  
  4778.         GetPort(&savedPort);
  4779.         aDialog = GetNewDialog(1004, nil, (WindowPtr)-1);
  4780.         ShowWindow(aDialog);
  4781.         SetPort(aDialog);
  4782.         
  4783.         AdornDefaultButton(aDialog, kOutlineItem);
  4784.          
  4785.         /*set the edittext button to contain the right size*/
  4786.         NumToString(*whatSize, aString);
  4787.         SetText(aDialog, kOtherSize, aString);
  4788.      
  4789.         do {
  4790.             ModalDialog(nil, &itemHit);
  4791.         } while ((itemHit!=kOK) && (itemHit!=kCancel));
  4792.         
  4793.         if (itemHit == kOK) 
  4794.             RetrieveText(aDialog, kOtherSize, aString);
  4795.     
  4796.         DisposDialog(aDialog);
  4797.         SetPort(savedPort);
  4798.         
  4799.         if (itemHit == kOK) 
  4800.          {
  4801.              /*set the new size of the text*/
  4802.              StringToNum(aString, whatSize);
  4803.              if ((*whatSize<1) || (*whatSize>2000)) 
  4804.                  *whatSize = 12;
  4805.          }
  4806.         return(itemHit == kOK);
  4807.     }
  4808.     
  4809. pascal void IssueSizeCommand(DPtr theDocument,short theItem)
  4810.     {
  4811.         Str255        name;
  4812.         AEDesc        sizeDesc;
  4813.         AEAddressDesc theAddress;
  4814.         OSErr         err;
  4815.         AEDesc        selTextObj;
  4816.         
  4817.         /*
  4818.             Vars to do with menu processing
  4819.         */
  4820.         short     lastSize;
  4821.         short     upItem;
  4822.         short     downItem;
  4823.         short     otherItem;
  4824.         long      theSize;
  4825.         TextStyle theStyle;
  4826.         short     lineHeight;
  4827.         short     fontAscent;
  4828.             
  4829.         err = MakeSelfAddress(&theAddress);
  4830.         
  4831.         err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &selTextObj);        
  4832.  
  4833.      /*check if the item is on the Size menu*/
  4834.      /*remembering that we can add and delete items from it*/
  4835.      lastSize  = CountMItems(myMenus[sizeM]) - 5;
  4836.      upItem    = lastSize + 2;
  4837.      downItem  = upItem + 1;
  4838.      otherItem = downItem + 2;
  4839.       
  4840.      TEGetStyle((**(theDocument->theText)).selStart,
  4841.                 &theStyle,
  4842.                             &lineHeight,
  4843.                             &fontAscent,
  4844.                             theDocument->theText);
  4845.         
  4846.      GetItem(myMenus[sizeM], theItem, name);
  4847.      
  4848.      if (theItem <= lastSize)
  4849.        {
  4850.          GetItem(myMenus[sizeM], theItem, name);
  4851.        StringToNum(name, &theSize);
  4852.        }
  4853.      else
  4854.        if (theItem == upItem)  
  4855.             theSize = theStyle.tsSize+1;
  4856.          else
  4857.             if (theItem == downItem)
  4858.                       theSize = theStyle.tsSize-1;
  4859.                  else 
  4860.                     if (theItem == otherItem) 
  4861.                         {
  4862.                           theSize = theStyle.tsSize;
  4863.                             if (!PoseSizeDialog(&theSize))
  4864.                                 return;
  4865.                         }
  4866.  
  4867.         if (err==noErr)
  4868.           err = CreateOffsetDescriptor(theSize, &sizeDesc);
  4869.             
  4870.         if (err==noErr)
  4871.             err = SendAESetObjProp(&selTextObj, 
  4872.                                                          pPointSize,
  4873.                                                          &sizeDesc,
  4874.                                                          &theAddress);
  4875.                                                      
  4876.     } /*IssueSizeCommand*/
  4877.     
  4878. pascal void IssueStyleCommand(DPtr theDocument, short theItem)
  4879.     {
  4880.         Style         theFace;
  4881.         OSErr         err;
  4882.         AEDesc        result;
  4883.         AEAddressDesc selfAddr;
  4884.         AEDesc        selTextObj;
  4885.         TextStyle     theStyle;
  4886.         short         lineHeight;
  4887.         short         fontAscent;
  4888.             
  4889.         TEGetStyle((**(theDocument->theText)).selStart,
  4890.                    &theStyle,
  4891.                              &lineHeight,
  4892.                              &fontAscent,
  4893.                              theDocument->theText);
  4894.         
  4895.         theFace = 0;
  4896.     switch (theItem) {
  4897.             case cPlain              : theFace = 0;
  4898.                                 break;
  4899.             case cBold                : theFace = bold;
  4900.                                 break;
  4901.             case cItalic            : theFace = italic;
  4902.                                 break;
  4903.             case cUnderline      : theFace = underline;
  4904.                                 break;
  4905.             case cOutline          : theFace = outline;
  4906.                                 break;
  4907.             case cShadow            : theFace = shadow;
  4908.                                 break;
  4909.             case cCondense        : theFace = condense;
  4910.                                 break;
  4911.             case cExtend            : theFace = extend;
  4912.                                 break;
  4913.     } /*of case */
  4914.  
  4915.     if (theFace==0)
  4916.             err = BuildTypeTextStylesDesc(0, bold+italic+underline+outline+shadow+condense+extend, &result);
  4917.     else
  4918.       if (theFace & theStyle.tsFace)
  4919.               err = BuildTypeTextStylesDesc(0, theFace, &result);
  4920.             else
  4921.               err = BuildTypeTextStylesDesc(theFace, 0, &result);
  4922.                 
  4923.         err = MakeSelfAddress(&selfAddr);
  4924.         
  4925.         if (err==noErr)
  4926.             err = MakeSelectedTextObj(theDocument->theWindow, theDocument->theText, &selTextObj);
  4927.         
  4928.         if (err==noErr)
  4929.             err = SendAESetObjProp(&selTextObj, 
  4930.                                                          pTextStyles,
  4931.                                                          &result,
  4932.                                                          &selfAddr);
  4933.         
  4934.     } /* IssueStyleCommand */
  4935.     
  4936. enum {
  4937.  
  4938. ETX = 0x03, /* Enter key on keyboard or keypad */
  4939. BS  = 0x08, /* Backspace key on keyboard       */
  4940. HT  = 0x09, /* Tab key on keyboard             */
  4941. CR  = 0x0D, /* Return key on keyboard          */
  4942. ESC = 0x1B, /* Clear key on keypad             */
  4943. FS  = 0x1C, /* Left arrow key on keypad        */
  4944. GS  = 0x1D, /* Right arrow key on keypad       */
  4945. RS  = 0x1E, /* Up arrow key on keypad          */
  4946. US  = 0x1F  /* Down arrow key on keypad        */
  4947. };
  4948.  
  4949. pascal OSErr IssueSetDataObjToBufferContents(const AEDesc * theObj)
  4950.     { 
  4951.       OSErr         myErr;
  4952.         OSErr                    ignoreErr;
  4953.         AEAddressDesc theAddress;
  4954.         AppleEvent    myAppleEvent;
  4955.         AppleEvent    defReply;
  4956.  
  4957.         myErr = MakeSelfAddress(&theAddress);
  4958.         
  4959.         /* create event */
  4960.         
  4961.         if (myErr==noErr)
  4962.             myErr = AECreateAppleEvent(kAECoreSuite,
  4963.                                                                  kAESetData,
  4964.                                                                  &theAddress,
  4965.                                                                  0,
  4966.                                                                  0,
  4967.                                                                  &myAppleEvent);
  4968.             
  4969.         /* add prop obj spec to the event */
  4970.         
  4971.         if (myErr==noErr)
  4972.             myErr = AEPutParamDesc(&myAppleEvent, keyDirectObject, theObj);
  4973.         
  4974.         /* add prop data to the event */
  4975.         
  4976.         if (myErr==noErr)
  4977.             myErr = AEPutParamPtr(&myAppleEvent,
  4978.                                                         keyAEData,
  4979.                                                         typeChar,
  4980.                                                         (Ptr)gTypingBuffer,
  4981.                                                         gCharsInBuffer);
  4982.                                                         
  4983.         /* send event */
  4984.         
  4985.         if (myErr==noErr)
  4986.             myErr = AESend(&myAppleEvent,
  4987.                                          &defReply,
  4988.                                          kAENoReply+kAEDontExecute,
  4989.                                          kAENormalPriority,
  4990.                                          kAEDefaultTimeout,
  4991.                                          nil,
  4992.                                          nil);
  4993.  
  4994.         if (theAddress.dataHandle)
  4995.             ignoreErr = AEDisposeDesc(&theAddress);
  4996.             
  4997.         if (myAppleEvent.dataHandle)
  4998.             ignoreErr = AEDisposeDesc(&myAppleEvent);
  4999.             
  5000.         return(myErr);
  5001.     }
  5002.  
  5003. pascal void AddKeyToTypingBuffer(DPtr theDocument, char theKey)
  5004.     {
  5005.         OSErr myErr;
  5006.         OSErr ignoreErr;
  5007.         
  5008.         if (theKey==BS || theKey==FS || theKey==GS || theKey==RS || theKey==US)
  5009.             {
  5010.                 FlushAndRecordTypingBuffer();
  5011.                 if (theKey==BS)
  5012.                     {
  5013.                         if ((**theDocument->theText).selStart!=(**theDocument->theText).selEnd)
  5014.                             {
  5015.                                 myErr = MakeTextObj(theDocument->theWindow,
  5016.                                                                         (**theDocument->theText).selStart,
  5017.                                                                         (**theDocument->theText).selEnd,
  5018.                                                                         &gTypingTargetObject);
  5019.                             }
  5020.                         else
  5021.                             {
  5022.                                 myErr = MakeTextObj(theDocument->theWindow,
  5023.                                                                         (**theDocument->theText).selStart-1,
  5024.                                                                         (**theDocument->theText).selStart,
  5025.                                                                         &gTypingTargetObject);
  5026.                             }
  5027.                             
  5028.                     myErr = IssueSetDataObjToBufferContents(&gTypingTargetObject);
  5029.                         
  5030.                         ignoreErr = AEDisposeDesc(&gTypingTargetObject);
  5031.                         
  5032.                         gTypingTargetObject.dataHandle = nil;
  5033.                     }
  5034.             }
  5035.         else
  5036.             {
  5037.                 if (gCharsInBuffer==0)
  5038.                     myErr = MakeSelectedTextObj(theDocument->theWindow,
  5039.                                                                             theDocument->theText,
  5040.                                                                             &gTypingTargetObject);
  5041.  
  5042.                 gTypingBuffer[gCharsInBuffer++] = theKey;
  5043.             }
  5044.           
  5045.     }
  5046.     
  5047. pascal void FlushAndRecordTypingBuffer(void)
  5048.     { 
  5049.       OSErr  myErr;
  5050.         OSErr  ignoreErr;
  5051.  
  5052.         if (gCharsInBuffer != 0)
  5053.             {
  5054.                 myErr = IssueSetDataObjToBufferContents(&gTypingTargetObject);
  5055.                 
  5056.                 if (gTypingTargetObject.dataHandle)
  5057.                     ignoreErr = AEDisposeDesc(&gTypingTargetObject);
  5058.             }
  5059.             
  5060.         gCharsInBuffer = 0;
  5061.         gTypingTargetObject.dataHandle = 0;
  5062.     }
  5063.     
  5064. /*****************************************************************************/
  5065. /*
  5066.     Object Accessors
  5067. */
  5068.     
  5069. pascal OSErr WindowFromNullAccessor(DescType      wantClass,
  5070.                                                                     const AEDesc  *container,
  5071.                                                                         DescType      containerClass,
  5072.                                                                         DescType      form, 
  5073.                                                                         const AEDesc  *selectionData,
  5074.                                                                         AEDesc        *value,
  5075.                                                                         long          theRefCon)
  5076.     {
  5077. #pragma unused (container,theRefCon)
  5078.     
  5079.         OSErr       myErr;
  5080.         Str255      nameStr;
  5081.         WindowToken theWindow;
  5082.         short       index;
  5083.         AEDesc      resultDesc;
  5084.         
  5085.         myErr = errAEBadKeyForm;    /* or whatever */
  5086.         
  5087.         value->dataHandle     = nil;
  5088.         resultDesc.dataHandle = nil;
  5089.         
  5090.         /* 
  5091.             should only be called with wantClass = cWindow and
  5092.             with containerClass = typeNull or typeMyAppl.
  5093.             Currently accept as either formName or formAbsolutePosition
  5094.         */
  5095.         
  5096.         if ((wantClass != cWindow) || 
  5097.               ((containerClass != typeNull) && (containerClass != typeMyAppl)) ||
  5098.                !((form == formName) || (form == formAbsolutePosition)))
  5099.             return(errAEWrongDataType);
  5100.         
  5101.         if (form == formName)
  5102.             {
  5103.                 myErr     = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  5104.                 theWindow = WindowNameToWindowPtr(nameStr);
  5105.             }
  5106.         
  5107.         if (form == formAbsolutePosition)
  5108.             {
  5109.                 myErr         = GetIntegerFromDescriptor(selectionData, &index);
  5110.                 
  5111.                 if (index<0)
  5112.                     index = CountWindows()+index+1;
  5113.                     
  5114.                 theWindow = GetWindowPtrOfNthWindow(index);
  5115.             }
  5116.             
  5117.         if (myErr == noErr)
  5118.             myErr = AECreateDesc(typeMyWndw, (Ptr)&theWindow, sizeof(theWindow), value);
  5119.                 
  5120.         return(myErr);
  5121.     }    /* WindowFromNullAccessor */
  5122.  
  5123. pascal OSErr ApplicationFromNullAccessor(DescType      wantClass,
  5124.                                                                                  const AEDesc  *container,
  5125.                                                                                  DescType      containerClass,
  5126.                                                                                  DescType      form, 
  5127.                                                                                  const AEDesc  *selectionData,
  5128.                                                                                  AEDesc        *value,
  5129.                                                                                  long          theRefCon)
  5130.     {
  5131. #pragma unused (container,selectionData,theRefCon)
  5132.  
  5133.         OSErr    myErr;
  5134.         appToken theApp;
  5135.         AEDesc   resultDesc;
  5136.         
  5137.         value->dataHandle     = nil;
  5138.         resultDesc.dataHandle = nil;
  5139.         
  5140.         /* 
  5141.             should only be called with wantClass = cWindow and
  5142.             with containerClass = typeNull.
  5143.             Currently accept as either formName or formAbsolutePosition
  5144.         */
  5145.         
  5146.         if ((wantClass != cApplication) || (containerClass != typeNull) ||
  5147.               !((form == formName) || (form == formAbsolutePosition)))
  5148.             return(errAEWrongDataType);
  5149.         
  5150.         if ((form == formName) || (form == formAbsolutePosition))
  5151.             {
  5152.                 theApp.highLongOfPSN = 0;
  5153.                 theApp.lowLongOfPSN  = kCurrentProcess;
  5154.             }
  5155.             
  5156.         myErr = AECreateDesc(typeMyAppl, (Ptr)&theApp, sizeof(theApp), value);
  5157.                 
  5158.         return(myErr);
  5159.     }    /* ApplicationFromNullAccessor */
  5160.  
  5161. pascal void MoveToNonSpace(short *start, short limit, charsHandle myChars)
  5162.     /*
  5163.         Treats space,comma, full stop, ; and : as space chars
  5164.     */
  5165.     { 
  5166.         short x;
  5167.  
  5168.         while (*start<=limit) {
  5169.           x = (**myChars)[*start];
  5170.             if ( x == ' ' ||
  5171.                  x == ',' ||
  5172.                  x == '.' ||
  5173.                  x == ',' ||
  5174.                  x == ':' ||
  5175.                  x == 10  ||
  5176.                  x == 13 )
  5177.                 (*start) +=1;
  5178.             else
  5179.                 return;
  5180.         }
  5181.     }
  5182.     
  5183. pascal void MoveToSpace(short *start, short limit, charsHandle myChars)
  5184.     /*
  5185.         Treats space,comma, full stop, ; and : as space chars
  5186.     */
  5187.     { 
  5188.       short x;
  5189.         
  5190.         while (*start<=limit) {
  5191.           x = (**myChars)[*start];
  5192.             if ( x != ' ' &&
  5193.                  x != ',' &&
  5194.                  x != '.' &&
  5195.                  x != ',' &&
  5196.                  x != ':' &&
  5197.                  x != 10  &&
  5198.                  x != 13 )
  5199.                 (*start) +=1;
  5200.             else
  5201.                 return;
  5202.         }
  5203.     }
  5204.  
  5205. pascal short CountWords(TEHandle inTextHandle, short startAt, short forHowManyChars)
  5206.     {
  5207.         charsHandle myChars;
  5208.         short       start;
  5209.         short       limit;
  5210.         short       myWords;
  5211.             
  5212.         myChars  = (charsHandle)(**inTextHandle).hText;
  5213.         limit    = startAt+forHowManyChars-1;
  5214.         start    = startAt;
  5215.         myWords  = 0;
  5216.         MoveToNonSpace(&start, limit, myChars);
  5217.         while (start<=limit) {
  5218.                 myWords++;
  5219.                 MoveToSpace(&start, limit, myChars);
  5220.                 MoveToNonSpace(&start, limit, myChars);
  5221.             }
  5222.         return(myWords);
  5223.     } /* CountWords */
  5224.     
  5225. pascal void GetNthWordInfo(short    whichWord,
  5226.                                                    TEHandle inTextHandle,
  5227.                                                    short    *wordStartChar,
  5228.                                                    short    *wordLength)
  5229.     /*
  5230.         On entry:    wordStartChar is start of char range to count in
  5231.                             wordLength is number of chars to consider
  5232.                             
  5233.         On Exit : wordStartChar is start of requested word
  5234.                             wordLength is number of chars in word
  5235.     */
  5236.     {
  5237.         charsHandle myChars;
  5238.         short       start;
  5239.         short       limit;
  5240.             
  5241.         myChars  = (charsHandle)(**inTextHandle).hText;
  5242.         limit    = *wordStartChar + *wordLength-1;
  5243.         start    = *wordStartChar;
  5244.         MoveToNonSpace(&start, limit, myChars);
  5245.         while ((start<=limit) && (whichWord>0)) {
  5246.  
  5247.                 whichWord       = whichWord-1;
  5248.                 *wordStartChar  = start;
  5249.                 MoveToSpace(&start, limit, myChars);
  5250.                 *wordLength     = start- *wordStartChar;
  5251.                     
  5252.                 MoveToNonSpace(&start, limit, myChars);
  5253.             }
  5254.     } /* GetNthWordInfo */
  5255.     
  5256. pascal void GetWordInfo(short    whichWord,
  5257.                                               TEHandle inTextHandle,
  5258.                                               short    *wordStartChar,
  5259.                                               short    *wordLength)
  5260.     /*
  5261.         On wordStartChar entry is start of char range to count in
  5262.                             wordLength is number of chars to consider
  5263.                             
  5264.         On Exit : wordStartChar is start of requested word
  5265.                             wordLength is number of chars in word
  5266.     */
  5267.     {
  5268.         short noOfWords;
  5269.                     
  5270.         noOfWords = CountWords(inTextHandle, *wordStartChar, *wordLength);
  5271.         
  5272.         if (whichWord<0)
  5273.             whichWord = noOfWords + whichWord + 1;
  5274.             
  5275.         if (whichWord>noOfWords)
  5276.             {
  5277.                 *wordStartChar = *wordStartChar+*wordLength;
  5278.                 *wordLength    = 0;
  5279.             }
  5280.         else
  5281.             GetNthWordInfo(whichWord, inTextHandle, wordStartChar, wordLength);
  5282.     }
  5283.     
  5284. pascal short CountLines(TEHandle inTextHandle)
  5285.     {
  5286.         /*
  5287.             CountLines makes use of info in TERec
  5288.         */
  5289.         return((**inTextHandle).nLines);
  5290.     }
  5291.     
  5292. pascal short LineOfOffset(TEHandle theHTE, short charOffset)
  5293.     {
  5294.         short n;
  5295.     
  5296.         n = (**theHTE).nLines;
  5297.         
  5298.         while (((**theHTE).lineStarts[n-1]>charOffset) &&
  5299.                      (n>0))
  5300.              n--;
  5301.             
  5302.         return(n);
  5303.     } /* LineOfOffset */
  5304.  
  5305. pascal void GetLineInfo(short    whichLine,
  5306.                                                 TEHandle inTextHandle,
  5307.                                               short    *lineStartChar,
  5308.                                               short    *lineLength)
  5309.     {
  5310.         short       noOfLines;
  5311.         charsHandle myChars;
  5312.         
  5313.         /* Addition of lines within text object */
  5314.         short       lineOfStart;
  5315.         short       lineOfEnd;
  5316.         
  5317.         lineOfStart = LineOfOffset(inTextHandle, *lineStartChar);
  5318.         lineOfEnd   = LineOfOffset(inTextHandle, *lineStartChar+*lineLength-1);
  5319.             
  5320.         myChars   = (charsHandle)(**inTextHandle).hText;
  5321.         noOfLines = lineOfEnd - lineOfStart + 1;
  5322.         
  5323.         if (whichLine<0)
  5324.             whichLine = noOfLines + whichLine + 1;
  5325.             
  5326.         noOfLines = CountLines(inTextHandle);
  5327.         whichLine = whichLine + lineOfStart - 1; /* convert offset relative to offset absolute */
  5328.         
  5329.         /* End of addition */
  5330.         
  5331.         if (whichLine<=lineOfEnd)
  5332.             {
  5333.                 *lineStartChar = (**inTextHandle).lineStarts[whichLine-1];
  5334.                 if (whichLine==noOfLines)
  5335.                     *lineLength  = (**inTextHandle).teLength;
  5336.                 else
  5337.                     *lineLength  = (**inTextHandle).lineStarts[whichLine];
  5338.                 *lineLength    = *lineLength-*lineStartChar;
  5339.                 /*
  5340.                     Don't return CR
  5341.                 */
  5342.                 if ((**myChars)[ *lineStartChar+*lineLength-1] == 13)
  5343.                     *lineLength = *lineLength-1;
  5344.             }
  5345.         else
  5346.             {
  5347.                 if (whichLine<noOfLines)
  5348.                   *lineStartChar = (**inTextHandle).lineStarts[whichLine]; /* start of whichLine++ */
  5349.                 else
  5350.                     *lineStartChar = (**inTextHandle).teLength;
  5351.                 *lineLength    = 0;
  5352.             }
  5353.     } /* GetLineInfo */
  5354.     
  5355. pascal OSErr TextElemFromWndwAccessor(DescType     wantClass,
  5356.                                                                         const AEDesc *container,
  5357.                                                                         DescType     containerClass,
  5358.                                                                         DescType     form,
  5359.                                                                         const AEDesc *selectionData,
  5360.                                                                         AEDesc       *value,
  5361.                                                                             long         theRefCon)
  5362.   { 
  5363. #pragma unused (theRefCon)
  5364.     
  5365.         OSErr       myErr;
  5366.         OSErr       ignoreErr;
  5367.         WindowToken theWindow;
  5368.         Size        actSize;
  5369.         long        index;
  5370.         TextToken   theTextToken;
  5371.         AERecord    selectionRecord;
  5372.         TextToken   startText;
  5373.         TextToken   stopText;
  5374.         DescType    returnedType;
  5375.         AEDesc      windDesc;
  5376.         TEHandle    theHTE;
  5377.         DPtr        theDocument;
  5378.         short       wordStartChar;
  5379.         short       wordLength;
  5380.     
  5381.         myErr = -1700;    /* or whatever */
  5382.         
  5383.         selectionRecord.dataHandle = nil;
  5384.         
  5385.         /* do some checking for robustness' sake */
  5386.         
  5387.         if ((containerClass != cWindow) ||
  5388.               ((wantClass != cChar) && 
  5389.                  (wantClass != cSpot) && 
  5390.                  (wantClass != cWord) &&
  5391.                  (wantClass != cLine)    ) ||
  5392.               ((form!=formRange) && (form!=formAbsolutePosition)))
  5393.             return(errAEWrongDataType);
  5394.             
  5395.         /* let's get the window which contains the text element */
  5396.         
  5397.         myErr = AECoerceDesc(container, typeMyWndw, &windDesc);
  5398.         GetRawDataFromDescriptor(    &windDesc,
  5399.                                                             (Ptr)&theWindow,
  5400.                                                             sizeof(theWindow),
  5401.                                                             &actSize);
  5402.         ignoreErr = AEDisposeDesc(&windDesc);
  5403.                                                             
  5404.         if (theWindow==nil)
  5405.             myErr = errAEIllegalIndex;
  5406.         else
  5407.             {
  5408.                                                                                     
  5409.                 theTextToken.tokenWindow = theWindow;
  5410.                 
  5411.                 theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  5412.                 theHTE      = theDocument->theText;
  5413.                 
  5414.                 if (form == formAbsolutePosition)
  5415.                     {
  5416.                         myErr = GetLongIntFromDescriptor(selectionData, &index);
  5417.                         
  5418.                         if (wantClass==cSpot)
  5419.                             {
  5420.                               if (index<0)
  5421.                                     theTextToken.tokenOffset = (**theHTE).teLength+index+2; /* Past last char */
  5422.                                 else
  5423.                                     theTextToken.tokenOffset = index;
  5424.                                     
  5425.                                 theTextToken.tokenLength = 0;
  5426.                             }
  5427.                             
  5428.                         if (wantClass==cChar)
  5429.                             {
  5430.                                 if (index<0)
  5431.                                     theTextToken.tokenOffset = (**theHTE).teLength+index+1;
  5432.                                 else
  5433.                                   theTextToken.tokenOffset = index;
  5434.                                     
  5435.                                 theTextToken.tokenLength = 1;
  5436.                             }
  5437.                         
  5438.                         if (wantClass==cWord)
  5439.                             {
  5440.                                 wordStartChar = 0;
  5441.                                 wordLength    = (**theHTE).teLength;
  5442.                                 GetWordInfo(index, theHTE, &wordStartChar, &wordLength); /* zero based */
  5443.                                 theTextToken.tokenOffset = wordStartChar+1;
  5444.                                 theTextToken.tokenLength = wordLength;
  5445.                             }
  5446.                             
  5447.                         if (wantClass==cLine)
  5448.                             {
  5449.                                 wordStartChar = 0;
  5450.                                 wordLength    = (**theHTE).teLength;
  5451.                                 GetLineInfo(index, theHTE, &wordStartChar, &wordLength); /* zero based */
  5452.                                 theTextToken.tokenOffset = wordStartChar+1;
  5453.                                 theTextToken.tokenLength = wordLength;
  5454.                             }
  5455.                     }    /* of formAbsolutePosition */
  5456.                 
  5457.                 if (form == formRange)
  5458.                     {
  5459.                         /* coerce the selection data into an AERecord */
  5460.                         
  5461.                          myErr = AECoerceDesc(selectionData, typeAERecord, &selectionRecord);
  5462.                         
  5463.                         /* get the start object as a text token - 
  5464.                                 this will reenter this proc but as formAbsolutePosition via the coercion handler*/
  5465.                         
  5466.                         myErr =  AEGetKeyPtr(&selectionRecord,
  5467.                                                                  keyAERangeStart,
  5468.                                                                  typeMyText,
  5469.                                                                  &returnedType,
  5470.                                                                  (Ptr)&startText,
  5471.                                                                  sizeof(startText),
  5472.                                                                  &actSize);
  5473.                         
  5474.                         /* now do the same for the stop object */
  5475.                         
  5476.                         if (myErr==noErr)
  5477.                             myErr =  AEGetKeyPtr(&selectionRecord,
  5478.                                                                      keyAERangeStop,
  5479.                                                                      typeMyText,
  5480.                                                                      &returnedType,
  5481.                                                                      (Ptr)&stopText,
  5482.                                                                      sizeof(stopText),
  5483.                                                                      &actSize);
  5484.                         
  5485.                         if (myErr==noErr)
  5486.                             if ((theTextToken.tokenWindow != stopText.tokenWindow) ||
  5487.                                   (theTextToken.tokenWindow != startText.tokenWindow))
  5488.                                 myErr = errAECorruptData;    /* or whatever ????*/
  5489.                             
  5490.                         theTextToken.tokenOffset  = startText.tokenOffset;            
  5491.                         theTextToken.tokenLength  = stopText.tokenOffset +
  5492.                                                                                  stopText.tokenLength - 
  5493.                                                                                  startText.tokenOffset;
  5494.                                                                                  
  5495.                         if (theTextToken.tokenLength<0)
  5496.                             myErr = errAECorruptData;    /* or whatever */
  5497.                                                                              
  5498.                         ignoreErr = AEDisposeDesc(&selectionRecord);
  5499.                         
  5500.                     }    /* of formRange */
  5501.             }
  5502.         
  5503.         /* return theTextToken in a descriptor */
  5504.         
  5505.         if (myErr==noErr)
  5506.             myErr = AECreateDesc(typeMyText,
  5507.                                                      (Ptr)&theTextToken,
  5508.                                                      sizeof(theTextToken),
  5509.                                                      value);
  5510.                 
  5511.         return(myErr);
  5512.     }    /* TextElemFromWndwAccessor */
  5513.  
  5514. pascal OSErr TextElemFromTextAccessor(DescType     wantClass,
  5515.                                                                         const AEDesc *container,
  5516.                                                                         DescType     containerClass,
  5517.                                                                         DescType     form,
  5518.                                                                         const AEDesc *selectionData,
  5519.                                                                         AEDesc       *value,
  5520.                                                                         long         theRefCon)
  5521.     { 
  5522. #pragma unused (theRefCon, containerClass)
  5523.  
  5524.         OSErr       myErr;
  5525.         OSErr       ignoreErr;
  5526.         Size        actSize;
  5527.         long        index;
  5528.         TextToken   theTextToken;
  5529.         AERecord    selectionRecord;
  5530.         TextToken   startText;
  5531.         TextToken   stopText;
  5532.         DescType    returnedType;
  5533.         AEDesc      textDesc;
  5534.         TEHandle    theHTE;
  5535.         short       wordStartChar;
  5536.         short       wordLength;
  5537.         DPtr        theDocument;
  5538.     
  5539.         myErr = -1700;    /* or whatever */
  5540.             
  5541.         /* do some checking for robustness' sake */
  5542.         
  5543.         if (((wantClass != cChar) && 
  5544.                  (wantClass != cSpot) && 
  5545.                  (wantClass != cLine) && 
  5546.                  (wantClass != cWord)) ||
  5547.               ((form != formAbsolutePosition) && (form != formRange)))
  5548.             return(errAEWrongDataType);
  5549.         
  5550.         /* let's get the src text */
  5551.         
  5552.         myErr = AECoerceDesc(container, typeMyText, &textDesc);
  5553.         GetRawDataFromDescriptor(    &textDesc,
  5554.                                                             (Ptr)&theTextToken,
  5555.                                                             sizeof(theTextToken),
  5556.                                                             &actSize);
  5557.                                                             
  5558.         ignoreErr = AEDisposeDesc(&textDesc);
  5559.                                                             
  5560.         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  5561.         theHTE      = theDocument->theText;
  5562.         
  5563.         if (form == formAbsolutePosition)
  5564.             {
  5565.                 myErr = GetLongIntFromDescriptor(selectionData, &index);
  5566.                 
  5567.                 if (wantClass==cSpot)
  5568.                     {
  5569.                         if (index<0)
  5570.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  5571.                         else
  5572.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  5573.                         theTextToken.tokenLength = 0;
  5574.                     }
  5575.                     
  5576.                 if (wantClass==cChar)
  5577.                     {
  5578.                         if (index<0)
  5579.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index+1+theTextToken.tokenLength;
  5580.                         else
  5581.                             theTextToken.tokenOffset = theTextToken.tokenOffset+index-1;
  5582.                         theTextToken.tokenLength = 1;
  5583.                     }
  5584.                                     
  5585.                 if (wantClass==cWord)
  5586.                     {
  5587.                         wordStartChar = theTextToken.tokenOffset-1;
  5588.                         wordLength    = theTextToken.tokenLength;
  5589.                         
  5590.                         GetWordInfo(index, theHTE, &wordStartChar, &wordLength);/*zero based*/
  5591.                         
  5592.                         theTextToken.tokenOffset = wordStartChar+1;
  5593.                         theTextToken.tokenLength = wordLength;
  5594.                     }
  5595.                     
  5596.                 if (wantClass==cLine)
  5597.                     {
  5598.                         wordStartChar = theTextToken.tokenOffset-1;
  5599.                         wordLength    = theTextToken.tokenLength;
  5600.                         
  5601.                         GetLineInfo(index, theHTE, &wordStartChar, &wordLength);
  5602.                         
  5603.                         theTextToken.tokenOffset = wordStartChar+1;
  5604.                         theTextToken.tokenLength = wordLength;
  5605.                     }
  5606.     
  5607.             }    /* of formAbsolutePosition */
  5608.         
  5609.         
  5610.         if (form == formRange)
  5611.             {
  5612.                 /* coerce the selection data into an AERecord */
  5613.                 
  5614.                  myErr = AECoerceDesc(selectionData, typeAERecord, &selectionRecord);
  5615.                 
  5616.                 /* get the start object as a text token - 
  5617.                         this will reenter this proc but as formAbsolutePosition via the coercion handler*/
  5618.                 
  5619.                 myErr =  AEGetKeyPtr(&selectionRecord,
  5620.                                                          keyAERangeStart,
  5621.                                                          typeMyText,
  5622.                                                          &returnedType,
  5623.                                                          (Ptr)&startText,
  5624.                                                          sizeof(startText),
  5625.                                                          &actSize);
  5626.                 
  5627.                 /* now do the same for the stop object */
  5628.                 
  5629.                 if (myErr==noErr)
  5630.                     myErr =  AEGetKeyPtr(&selectionRecord,
  5631.                                                              keyAERangeStop,
  5632.                                                              typeMyText,
  5633.                                                              &returnedType,
  5634.                                                              (Ptr)&stopText,
  5635.                                                              sizeof(stopText),
  5636.                                                              &actSize);
  5637.                 
  5638.                 if (myErr==noErr)
  5639.                     if ((theTextToken.tokenWindow != stopText.tokenWindow) ||
  5640.                           (theTextToken.tokenWindow != startText.tokenWindow))
  5641.                         myErr = errAECorruptData;    /* or whatever */
  5642.                     
  5643.                 theTextToken.tokenOffset  = startText.tokenOffset;            
  5644.                 theTextToken.tokenLength  = stopText.tokenOffset +
  5645.                                                                          stopText.tokenLength - 
  5646.                                                                          startText.tokenOffset;
  5647.                                                                      
  5648.                 ignoreErr = AEDisposeDesc(&selectionRecord);
  5649.             }    /* of formRange */
  5650.             
  5651.         /* return theTextToken in a descriptor */
  5652.         
  5653.         myErr = AECreateDesc( typeMyText,
  5654.                                                     (Ptr)&theTextToken,
  5655.                                                     sizeof(theTextToken),
  5656.                                                     value);
  5657.             
  5658.         return(myErr);
  5659.     }    /* TextElemFromTextAccessor */
  5660.  
  5661. pascal OSErr PropertyFromTextAccessor(DescType     wantClass,
  5662.                                                                             const AEDesc *container,
  5663.                                                                             DescType     containerClass,
  5664.                                                                             DescType     form, 
  5665.                                                                             const AEDesc *selectionData,
  5666.                                                                             AEDesc       *value,
  5667.                                                                             long         theRefCon)
  5668.   {
  5669. #pragma unused (theRefCon, containerClass)
  5670.     
  5671.         OSErr         myErr;
  5672.         OSErr         ignoreErr;
  5673.         TextToken     theTextToken;
  5674.         DescType      theProperty;
  5675.         AEDesc        textDesc;
  5676.         AEDesc        propDesc;
  5677.         Size          actualSize;
  5678.         textPropToken myTextProp;
  5679.             
  5680.         value->dataHandle   = nil;
  5681.         textDesc.dataHandle = nil;
  5682.         propDesc.dataHandle = nil;
  5683.         
  5684.         if ((wantClass != cProperty) ||
  5685.                 (form != formPropertyID))
  5686.             {
  5687.                 return(errAEWrongDataType);
  5688.             }
  5689.         
  5690.         /* get the text token */
  5691.         myErr = AECoerceDesc(container, typeMyText, &textDesc);
  5692.         GetRawDataFromDescriptor(    &textDesc,
  5693.                                                             (Ptr)&theTextToken,
  5694.                                                             sizeof(theTextToken),
  5695.                                                             &actualSize);
  5696.                 
  5697.         /* get the property */
  5698.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5699.         GetRawDataFromDescriptor(&propDesc,
  5700.                                                          (Ptr)&theProperty,
  5701.                                                          sizeof(theProperty),
  5702.                                                          &actualSize);
  5703.         /*
  5704.             Combine the two into single token
  5705.         */
  5706.         myTextProp.propertyTextToken = theTextToken;
  5707.         myTextProp.propertyProperty  = theProperty;
  5708.         
  5709.         myErr = AECreateDesc(typeMyTextProp,
  5710.                                                  (Ptr)&myTextProp,
  5711.                                                  sizeof(myTextProp),
  5712.                                                  value);
  5713.             
  5714.         if (textDesc.dataHandle)
  5715.             ignoreErr = AEDisposeDesc(&textDesc);
  5716.             
  5717.         if (propDesc.dataHandle)
  5718.             ignoreErr = AEDisposeDesc(&propDesc);
  5719.             
  5720.         return(myErr);
  5721. }    /* PropertyFromTextAccessor */
  5722.  
  5723. pascal OSErr PropertyFromWndwAccessor(DescType     wantClass,
  5724.                                                                         const AEDesc *container,
  5725.                                                                         DescType     containerClass,
  5726.                                                                         DescType     form, 
  5727.                                                                         const AEDesc *selectionData,
  5728.                                                                         AEDesc       *value,
  5729.                                                                         long         theRefCon)
  5730.   { 
  5731. #pragma unused (theRefCon, containerClass)
  5732.     
  5733.         OSErr           myErr;
  5734.         OSErr           ignoreErr;
  5735.         WindowToken     theWindowToken;
  5736.         DescType        theProperty;
  5737.         AEDesc          windowDesc;
  5738.         AEDesc          propDesc;
  5739.         Size            actualSize;
  5740.         windowPropToken myWindowProp;
  5741.         
  5742.         value->dataHandle     = nil;
  5743.         windowDesc.dataHandle = nil;
  5744.         propDesc.dataHandle   = nil;
  5745.         
  5746.         if ((wantClass != cProperty) ||
  5747.               (form != formPropertyID))
  5748.             {
  5749.                 return(errAEWrongDataType);
  5750.             }
  5751.         
  5752.         /* get the window token - it's the container */
  5753.         
  5754.         myErr = AECoerceDesc(container, typeMyWndw, &windowDesc);
  5755.         GetRawDataFromDescriptor(    &windowDesc,
  5756.                                                             (Ptr)&theWindowToken,
  5757.                                                             sizeof(theWindowToken),
  5758.                                                             &actualSize);
  5759.                                                             
  5760.         /* Check the window exists */
  5761.         
  5762.         if (theWindowToken==nil)
  5763.             myErr = errAEIllegalIndex;
  5764.         else
  5765.             {
  5766.             
  5767.                 /* get the property - it's in the selection data */
  5768.                 
  5769.                 myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5770.                 GetRawDataFromDescriptor(    &propDesc,
  5771.                                                                     (Ptr)&theProperty,
  5772.                                                                     sizeof(theProperty),
  5773.                                                                     &actualSize);
  5774.                 /*
  5775.                     Combine the two into single token
  5776.                 */
  5777.                 myWindowProp.tokenWindowToken = theWindowToken;
  5778.                 myWindowProp.tokenProperty    = theProperty;
  5779.                 
  5780.                 myErr = AECreateDesc( typeMyWindowProp,
  5781.                                                             (Ptr)&myWindowProp,
  5782.                                                             sizeof(myWindowProp),
  5783.                                                             value);
  5784.             }
  5785.             
  5786.         if (windowDesc.dataHandle)
  5787.             ignoreErr = AEDisposeDesc(&windowDesc);
  5788.             
  5789.         if (propDesc.dataHandle)
  5790.             ignoreErr = AEDisposeDesc(&propDesc);
  5791.             
  5792.         return(myErr);
  5793.   }    /* PropertyFromWndwAccessor */
  5794.  
  5795. pascal OSErr PropertyFromApplAccessor(DescType     wantClass,
  5796.                                                                             const AEDesc *container,
  5797.                                                                             DescType     containerClass,
  5798.                                                                             DescType     form, 
  5799.                                                                             const AEDesc *selectionData,
  5800.                                                                             AEDesc       *value,
  5801.                                                                             long         theRefCon)
  5802.   {
  5803. #pragma unused (theRefCon, containerClass)
  5804.     
  5805.         OSErr         myErr;
  5806.         OSErr         ignoreErr;
  5807.         appToken      theApplToken;
  5808.         DescType      theProperty;
  5809.         AEDesc        applDesc;
  5810.         AEDesc        propDesc;
  5811.         Size          actualSize;
  5812.         applPropToken myApplProp;
  5813.             
  5814.         value->dataHandle     = nil;
  5815.         applDesc.dataHandle   = nil;
  5816.         propDesc.dataHandle   = nil;
  5817.         
  5818.         if ((wantClass != cProperty) ||
  5819.               (form != formPropertyID))
  5820.             {
  5821.                 return(errAEWrongDataType);
  5822.             }
  5823.         
  5824.         /* get the application token - it's the container */
  5825.         
  5826.         myErr = AECoerceDesc(container, typeMyAppl, &applDesc);
  5827.         GetRawDataFromDescriptor(&applDesc,
  5828.                                                          (Ptr)&theApplToken,
  5829.                                                          sizeof(theApplToken),
  5830.                                                          &actualSize);
  5831.                 
  5832.         /* get the property - it's in the selection data */
  5833.         
  5834.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5835.         GetRawDataFromDescriptor(&propDesc,
  5836.                                                          (Ptr)&theProperty,
  5837.                                                          sizeof(theProperty),
  5838.                                                          &actualSize);
  5839.         /*
  5840.             Combine the two into single token
  5841.         */
  5842.         myApplProp.tokenApplToken    = theApplToken;
  5843.         myApplProp.tokenApplProperty = theProperty;
  5844.         
  5845.         myErr = AECreateDesc(typeMyApplProp,
  5846.                                                  (Ptr)&myApplProp,
  5847.                                                  sizeof(myApplProp),
  5848.                                                  value);
  5849.             
  5850.         if (applDesc.dataHandle)
  5851.             ignoreErr = AEDisposeDesc(&applDesc);
  5852.             
  5853.         if (propDesc.dataHandle)
  5854.             ignoreErr = AEDisposeDesc(&propDesc);
  5855.             
  5856.         return(myErr);
  5857. }    /* PropertyFromApplAccessor */
  5858.  
  5859. pascal OSErr MenuNameToMenuToken(const Str255 theName, MenuToken *theToken)
  5860.     {
  5861.         short   index;
  5862.         
  5863.         for (index=appleM; index<=kLastMenu; index++)
  5864.          {
  5865.                 if (IUEqualString(theName, (**(myMenus[index])).menuData)==0)
  5866.                   {
  5867.                         theToken->theTokenMenu = myMenus[index];
  5868.                         theToken->theTokenID   = index+appleID;
  5869.                         return(noErr);
  5870.                     }
  5871.          }
  5872.         return(errAEIllegalIndex);
  5873.     }
  5874.  
  5875. pascal OSErr MenuFromNullAccessor(DescType      wantClass,
  5876.                                                                     const AEDesc  *container,
  5877.                                                                     DescType      containerClass,
  5878.                                                                     DescType      form, 
  5879.                                                                     const AEDesc  *selectionData,
  5880.                                                                     AEDesc        *value,
  5881.                                                                     long          theRefCon)
  5882.     {
  5883. #pragma unused (container,theRefCon)
  5884.     
  5885.         OSErr       myErr;
  5886.         Str255      nameStr;
  5887.         MenuToken   theMenu;
  5888.         short       index;
  5889.         AEDesc      resultDesc;
  5890.         
  5891.         myErr = errAEBadKeyForm;    /* or whatever */
  5892.         
  5893.         value->dataHandle     = nil;
  5894.         resultDesc.dataHandle = nil;
  5895.         
  5896.         /* 
  5897.             should only be called with wantClass = cMenu and
  5898.             with containerClass = typeNull or typeMyAppl.
  5899.             Currently accept as either formName or formAbsolutePosition
  5900.         */
  5901.         
  5902.         if ((wantClass != cMenu) || 
  5903.               ((containerClass != typeNull) && (containerClass != typeMyAppl)) ||
  5904.                !((form == formName) || (form == formAbsolutePosition)))
  5905.             return(errAEWrongDataType);
  5906.         
  5907.         if (form == formName)
  5908.             {
  5909.                 myErr = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  5910.                 myErr = MenuNameToMenuToken(nameStr, &theMenu);
  5911.             }
  5912.         
  5913.         if (form == formAbsolutePosition)
  5914.             {
  5915.                 myErr     = GetIntegerFromDescriptor(selectionData, &index);
  5916.                 if (index<0)
  5917.                     index = kLastMenu + index + 1;
  5918.                     
  5919.                 if (index>0 && index<=kLastMenu+1)
  5920.                     {
  5921.                         theMenu.theTokenMenu = myMenus[index-1];
  5922.                         theMenu.theTokenID   = index-1+appleID;
  5923.                     }
  5924.                 else
  5925.               myErr = errAEIllegalIndex;    /* or whatever */
  5926.             }
  5927.             
  5928.         if (myErr == noErr)
  5929.             myErr = AECreateDesc(typeMyMenu, (Ptr)&theMenu, sizeof(theMenu), value);
  5930.                 
  5931.         return(myErr);
  5932.     }    /* MenuFromNullAccessor */
  5933.  
  5934. pascal OSErr PropertyFromMenuAccessor(DescType     wantClass,
  5935.                                                                             const AEDesc *container,
  5936.                                                                             DescType     containerClass,
  5937.                                                                             DescType     form, 
  5938.                                                                             const AEDesc *selectionData,
  5939.                                                                             AEDesc       *value,
  5940.                                                                             long         theRefCon)
  5941.   {
  5942. #pragma unused (theRefCon, containerClass)
  5943.     
  5944.         OSErr         myErr;
  5945.         OSErr         ignoreErr;
  5946.         MenuToken     theMenuToken;
  5947.         DescType      theProperty;
  5948.         AEDesc        menuDesc;
  5949.         AEDesc        propDesc;
  5950.         Size          actualSize;
  5951.         MenuPropToken myMenuProp;
  5952.             
  5953.         value->dataHandle     = nil;
  5954.         menuDesc.dataHandle   = nil;
  5955.         propDesc.dataHandle   = nil;
  5956.         
  5957.         if ((wantClass != cProperty) ||
  5958.               (form != formPropertyID))
  5959.             {
  5960.                 return(errAEWrongDataType);
  5961.             }
  5962.         
  5963.         /* get the menu token - it's the container */
  5964.         
  5965.         myErr = AECoerceDesc(container, typeMyMenu, &menuDesc);
  5966.         GetRawDataFromDescriptor(&menuDesc,
  5967.                                                          (Ptr)&theMenuToken,
  5968.                                                          sizeof(theMenuToken),
  5969.                                                          &actualSize);
  5970.                 
  5971.         /* get the property - it's in the selection data */
  5972.         
  5973.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  5974.         GetRawDataFromDescriptor(&propDesc,
  5975.                                                          (Ptr)&theProperty,
  5976.                                                          sizeof(theProperty),
  5977.                                                          &actualSize);
  5978.         /*
  5979.             Combine the two into single token
  5980.         */
  5981.         myMenuProp.theMenuToken = theMenuToken;
  5982.         myMenuProp.theMenuProp  = theProperty;
  5983.         
  5984.         myErr = AECreateDesc(typeMyMenuProp,
  5985.                                                  (Ptr)&myMenuProp,
  5986.                                                  sizeof(myMenuProp),
  5987.                                                  value);
  5988.             
  5989.         if (menuDesc.dataHandle)
  5990.             ignoreErr = AEDisposeDesc(&menuDesc);
  5991.             
  5992.         if (propDesc.dataHandle)
  5993.             ignoreErr = AEDisposeDesc(&propDesc);
  5994.             
  5995.         return(myErr);
  5996. }    /* PropertyFromMenuAccessor */
  5997.  
  5998. pascal OSErr PropertyFromMenuItemAccessor(DescType     wantClass,
  5999.                                                                                     const AEDesc *container,
  6000.                                                                                     DescType     containerClass,
  6001.                                                                                     DescType     form, 
  6002.                                                                                     const AEDesc *selectionData,
  6003.                                                                                     AEDesc       *value,
  6004.                                                                                     long         theRefCon)
  6005.   {
  6006. #pragma unused (theRefCon, containerClass)
  6007.     
  6008.         OSErr         myErr;
  6009.         OSErr         ignoreErr;
  6010.         MenuItemToken theMenuItemToken;
  6011.         DescType      theProperty;
  6012.         AEDesc        itemDesc;
  6013.         AEDesc        propDesc;
  6014.         Size          actualSize;
  6015.         MenuItemPropToken myItemProp;
  6016.             
  6017.         value->dataHandle     = nil;
  6018.         itemDesc.dataHandle   = nil;
  6019.         propDesc.dataHandle   = nil;
  6020.         
  6021.         if ((wantClass != cProperty) ||
  6022.               (form != formPropertyID))
  6023.             {
  6024.                 return(errAEWrongDataType);
  6025.             }
  6026.         
  6027.         /* get the menu token - it's the container */
  6028.         
  6029.         myErr = AECoerceDesc(container, typeMyMenuItem, &itemDesc);
  6030.         GetRawDataFromDescriptor(&itemDesc,
  6031.                                                          (Ptr)&theMenuItemToken,
  6032.                                                          sizeof(theMenuItemToken),
  6033.                                                          &actualSize);
  6034.                 
  6035.         /* get the property - it's in the selection data */
  6036.         
  6037.         myErr = AECoerceDesc(selectionData, typeType, &propDesc);
  6038.         GetRawDataFromDescriptor(&propDesc,
  6039.                                                          (Ptr)&theProperty,
  6040.                                                          sizeof(theProperty),
  6041.                                                          &actualSize);
  6042.         /*
  6043.             Combine the two into single token
  6044.         */
  6045.         myItemProp.theItemToken  = theMenuItemToken;
  6046.         myItemProp.theItemProp   = theProperty;
  6047.         
  6048.         myErr = AECreateDesc(typeMyItemProp,
  6049.                                                  (Ptr)&myItemProp,
  6050.                                                  sizeof(myItemProp),
  6051.                                                  value);
  6052.             
  6053.         if (itemDesc.dataHandle)
  6054.             ignoreErr = AEDisposeDesc(&itemDesc);
  6055.             
  6056.         if (propDesc.dataHandle)
  6057.             ignoreErr = AEDisposeDesc(&propDesc);
  6058.             
  6059.         return(myErr);
  6060. }    /* PropertyFromMenuItemAccessor */
  6061.  
  6062. pascal OSErr ItemNameToItemIndex(const Str255 theName, MenuHandle theMenu, short *theIndex)
  6063.     {
  6064.         short   index;
  6065.         short   maxItems;
  6066.         Str255  menuName;
  6067.         
  6068.         maxItems = CountMItems(theMenu);
  6069.         
  6070.         for (index=1; index<=maxItems; index++)
  6071.             {
  6072.                 GetItem(theMenu, index, menuName);
  6073.                 if (IUEqualString(theName, menuName)==0)
  6074.                     {
  6075.                         *theIndex = index;
  6076.                         return(noErr);
  6077.                     }
  6078.             }
  6079.         return(errAEIllegalIndex);
  6080.     }
  6081.     
  6082. pascal OSErr MenuItemFromMenuAccessor(DescType     wantClass,
  6083.                                                                             const AEDesc *container,
  6084.                                                                             DescType     containerClass,
  6085.                                                                             DescType     form, 
  6086.                                                                             const AEDesc *selectionData,
  6087.                                                                             AEDesc       *value,
  6088.                                                                             long         theRefCon)
  6089.   {
  6090. #pragma unused (theRefCon)
  6091.     
  6092.         OSErr         myErr;
  6093.         OSErr         ignoreErr;
  6094.         MenuItemToken theMenuItemToken;
  6095.         MenuToken     theMenuToken;
  6096.         AEDesc        menuDesc;
  6097.         Size          actualSize;
  6098.         Str255        nameStr;
  6099.         short         maxItems;
  6100.         short         index;
  6101.             
  6102.         value->dataHandle     = nil;
  6103.         menuDesc.dataHandle   = nil;
  6104.         
  6105.         if ((wantClass != cMenuItem) || (containerClass != cMenu) ||
  6106.               ((form != formAbsolutePosition) && (form != formName)))
  6107.             {
  6108.                 return(errAEWrongDataType);
  6109.             }
  6110.         
  6111.         /* get the menu token - it's the container */
  6112.         
  6113.         myErr = AECoerceDesc(container, typeMyMenu, &menuDesc);
  6114.         GetRawDataFromDescriptor(&menuDesc,
  6115.                                                          (Ptr)&theMenuToken,
  6116.                                                          sizeof(theMenuToken),
  6117.                                                          &actualSize);
  6118.                 
  6119.         if (form==formAbsolutePosition)
  6120.             {
  6121.                 myErr = GetIntegerFromDescriptor(selectionData, &index);
  6122.                 maxItems = CountMItems(theMenuToken.theTokenMenu);
  6123.                 
  6124.                 if (index<0)
  6125.                     index = maxItems + index + 1;
  6126.                     
  6127.                 if ((index<1) || (index>maxItems))
  6128.                   myErr = errAEIllegalIndex;
  6129.             }
  6130.             
  6131.         if (form == formName)
  6132.             {
  6133.                 myErr  = GetPStringFromDescriptor(selectionData, (char *)nameStr);
  6134.                 myErr  = ItemNameToItemIndex(nameStr, theMenuToken.theTokenMenu, &index);
  6135.             }
  6136.         
  6137.         /*
  6138.             Combine the two into single token
  6139.         */
  6140.     
  6141.         theMenuItemToken.theMenuToken  = theMenuToken;
  6142.         theMenuItemToken.theTokenItem  = index;
  6143.         
  6144.         if (myErr==noErr)
  6145.             myErr = AECreateDesc(typeMyMenuItem,
  6146.                                                      (Ptr)&theMenuItemToken,
  6147.                                                      sizeof(theMenuItemToken),
  6148.                                                      value);
  6149.             
  6150.         if (menuDesc.dataHandle)
  6151.             ignoreErr = AEDisposeDesc(&menuDesc);
  6152.             
  6153.         return(myErr);
  6154. }    /* MenuItemFromMenuAccessor */
  6155.  
  6156. /*******************************************************************************/
  6157. /*
  6158.     Stuff for counting objects
  6159. */
  6160.  
  6161. pascal OSErr MyCountProc(DescType     desiredType,
  6162.                                                DescType     containerClass,
  6163.                                                const AEDesc *container,
  6164.                                                long         *result)
  6165.                                             
  6166. /* so far all I count is:
  6167.   (1) the number of active windows in the app;
  6168.   (2) the number of words in a window 
  6169. */
  6170.  
  6171.     {   
  6172.         OSErr       myErr;
  6173.         OSErr       ignoreErr;
  6174.         WindowToken theWindowToken;
  6175.         DPtr        theDocument;
  6176.         TEHandle    theHTE;
  6177.         AEDesc      newDesc;
  6178.         short       wordStart;
  6179.         short       wordLength;
  6180.         Size        tokenSize;
  6181.         TextToken   theTextToken;
  6182.             
  6183.         *result = -1;    /* easily recognized illegal value */
  6184.             
  6185.         myErr = errAEWrongDataType;
  6186.         
  6187.         if (desiredType == cWindow)
  6188.             {
  6189.                 if ((containerClass == typeNull) ||
  6190.                       (containerClass == cApplication))
  6191.                     {
  6192.                         *result = CountWindows();
  6193.                         myErr = noErr;
  6194.                     }
  6195.             }
  6196.         else if ((desiredType == cWord) ||
  6197.               (desiredType == cLine) ||
  6198.               (desiredType == cChar))
  6199.             {
  6200.                 myErr = AECoerceDesc(container, typeMyWndw, &newDesc);
  6201.                 if (newDesc.descriptorType!=typeNull)
  6202.                     {
  6203.                         GetRawDataFromDescriptor(&newDesc,
  6204.                                                                          (Ptr)&theWindowToken,
  6205.                                                                          sizeof(theWindowToken),
  6206.                                                                          &tokenSize);
  6207.                                                                          
  6208.                         ignoreErr = AEDisposeDesc(&newDesc);
  6209.                                                                          
  6210.                         if (theWindowToken==nil)
  6211.                             myErr = errAEIllegalIndex;
  6212.                         else
  6213.                             {
  6214.                         
  6215.                                 theDocument = DPtrFromWindowPtr(theWindowToken);
  6216.                                 theHTE      = theDocument->theText;
  6217.                                 
  6218.                                 if (desiredType == cWord)
  6219.                                     {
  6220.                                         wordStart   = 0;
  6221.                                         wordLength  = (**theHTE).teLength;
  6222.                                         *result     = CountWords(theHTE, wordStart, wordLength);
  6223.                                     }
  6224.                                 
  6225.                                 if (desiredType == cChar)
  6226.                                     *result = (**theHTE).teLength;
  6227.                                     
  6228.                                 if (desiredType == cLine)
  6229.                                     *result = CountLines(theHTE);
  6230.                                     
  6231.                             }
  6232.                     }
  6233.                     
  6234.                 myErr = AECoerceDesc(container, typeMyText, &newDesc);
  6235.                 if (newDesc.descriptorType!=typeNull)
  6236.                     {
  6237.                         GetRawDataFromDescriptor(    &newDesc,
  6238.                                                                             (Ptr)&theTextToken,
  6239.                                                                             sizeof(theTextToken),
  6240.                                                                             &tokenSize);
  6241.                                                                          
  6242.                         ignoreErr = AEDisposeDesc(&newDesc);
  6243.                                                                          
  6244.                         theDocument = DPtrFromWindowPtr(theTextToken.tokenWindow);
  6245.                         theHTE      = theDocument->theText;
  6246.                         
  6247.                         if (desiredType == cWord)
  6248.                             {
  6249.                                 wordStart   = theTextToken.tokenOffset-1;
  6250.                                 wordLength  = theTextToken.tokenLength;
  6251.                                 *result     = CountWords(theHTE, wordStart, wordLength);
  6252.                             }
  6253.                         
  6254.                         if (desiredType == cChar)
  6255.                             *result = theTextToken.tokenLength;
  6256.                             
  6257.                         if (desiredType == cLine)
  6258.                             *result= LineOfOffset(theHTE,theTextToken.tokenOffset-1) - 
  6259.                                              LineOfOffset(theHTE,theTextToken.tokenOffset+theTextToken.tokenLength-1)
  6260.                                              +1;                        
  6261.                     }
  6262.                     
  6263.             }
  6264.             
  6265.         return(myErr);
  6266.     }    /* MyCountProc */
  6267.  
  6268. /*******************************************************************************/
  6269. /*
  6270.     Coercion Handlers - Allow AEResolve to do the hard work
  6271. */
  6272. pascal OSErr CoerceObjToAnything(const AEDesc *theAEDesc,
  6273.                                                              DescType     toType,
  6274.                                                          long         handlerRefCon,
  6275.                                                              AEDesc       *result)
  6276. /*
  6277.     CoerceObjToAnything functions by using AEResolve to do the hard
  6278.     work.
  6279. */
  6280.     {
  6281. #pragma unused (handlerRefCon)
  6282.     
  6283.         OSErr  myErr;
  6284.         OSErr  ignoreErr;
  6285.         
  6286.         AEDesc objDesc;
  6287.             
  6288.         myErr = errAECoercionFail;
  6289.         
  6290.         result->dataHandle = nil;
  6291.         objDesc.dataHandle = nil;
  6292.         
  6293.         
  6294.         if (theAEDesc->descriptorType != typeObjectSpecifier)
  6295.             {
  6296.                 return(errAEWrongDataType);
  6297.             }
  6298.         
  6299.         /* resolve the object specifier */
  6300.         myErr = AEResolve(theAEDesc, kAEIDoMinimum, &objDesc);
  6301.             
  6302.         /* hopefully it's the right type by now, but we'll give it a nudge */
  6303.         if (myErr==noErr)
  6304.             {
  6305.                 myErr = AECoerceDesc(&objDesc, toType, result);
  6306.                 ignoreErr = AEDisposeDesc(&objDesc);
  6307.             }
  6308.             
  6309.         return(myErr);
  6310.     }    /* CoerceObjToAnything */
  6311.  
  6312. /*******************************************************************************/
  6313.  
  6314. /*----------------------------------------------------------------------------------------------*/
  6315.  
  6316. /*now for the edition manager event handling code*/
  6317.  
  6318. pascal OSErr GetHandleFromEvent(const AppleEvent *theAppleEvent, SectionHandle *sectionH)
  6319.     
  6320.     {
  6321.         DescType ignoreType;
  6322.         Size          ignoreSize;
  6323.     
  6324.         return(AEGetKeyPtr(theAppleEvent, keyDirectObject, typeSectionH,
  6325.                                              &ignoreType, (Ptr)sectionH, sizeof(SectionHandle), &ignoreSize));
  6326.     } /* GetHandleFromEvent */
  6327.  
  6328. /*----------------------------------------------------------------------------------------------*/
  6329. pascal OSErr DoReadSection(const AppleEvent *theAppleEvent,AppleEvent *reply,long refCon)
  6330.     
  6331.     {
  6332. #pragma unused (reply, refCon)
  6333.     
  6334.         OSErr         err;
  6335.         SectionHandle sectionH;
  6336.     
  6337.         err = GetHandleFromEvent(theAppleEvent, §ionH);
  6338.         if (IsRegisteredSection(sectionH)==noErr)
  6339.             ReadAnEdition(sectionH);
  6340.         return(err);
  6341.     } /* DoReadSection */
  6342.     
  6343. /*----------------------------------------------------------------------------------------------*/
  6344. pascal OSErr DoWriteSection(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  6345.     
  6346.     {
  6347. #pragma unused (reply, refCon)
  6348.  
  6349.         OSErr         err;
  6350.         SectionHandle sectionH;
  6351.     
  6352.         err = GetHandleFromEvent(theAppleEvent, §ionH);
  6353.         if (IsRegisteredSection(sectionH) == noErr)
  6354.             WriteAnEdition(sectionH);
  6355.         
  6356.         return(err);
  6357.     } /* DoWriteSection */
  6358.  
  6359. /*----------------------------------------------------------------------------------------------*/
  6360. pascal OSErr DoScrollSection(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  6361.     {
  6362. #pragma unused (reply, refCon)
  6363.     
  6364.         OSErr         err;
  6365.         SectionHandle sectionH;
  6366.         SectHandle    aSectHandle;
  6367.     
  6368.         err = GetHandleFromEvent(theAppleEvent, §ionH);
  6369.         /*get at the sectHandle*/
  6370.         aSectHandle = (SectHandle)GetERefCon(sectionH);
  6371.         TESetSelect((**aSectHandle).fStart, (**aSectHandle).fEnd, ((**aSectHandle).fDocument)->theText);
  6372.         ShowSelect((**aSectHandle).fDocument);
  6373.         return(err);
  6374.     }
  6375.  
  6376. /*----------------------------------------------------------------------------------------------*/
  6377. pascal OSErr DoCancelSection(const AppleEvent *theAppleEvent, AppleEvent *reply, long refCon)
  6378.  
  6379.     {
  6380. #pragma unused (reply, refCon)
  6381.     
  6382.         OSErr         err;
  6383.         SectionHandle sectionH;
  6384.         SectHandle    aSectHandle;
  6385.             
  6386.         err = GetHandleFromEvent(theAppleEvent, §ionH);
  6387.         aSectHandle = (SectHandle)GetERefCon(sectionH);
  6388.         err = UnRegisterSection(sectionH);
  6389.         DeleteASection(aSectHandle, (**aSectHandle).fDocument);
  6390.         return(noErr);
  6391.     } /* DoCancelSection */
  6392.     
  6393. /* -----------------------------------------------------------------------
  6394.         Name:             InitAppleEvents
  6395.         Purpose:        Initialise the AppleEvent despatch table
  6396.      -----------------------------------------------------------------------**/
  6397.  
  6398. #pragma segment Main
  6399.  
  6400. #define noRefCon -1
  6401.  
  6402. pascal void InitAppleEvents(void)
  6403.     {
  6404.          OSErr aevtErr;
  6405.         
  6406.         gBigBrother    = 0;
  6407.         gCharsInBuffer = 0;
  6408.         gTypingBuffer  = (char *)NewPtr(32000);
  6409.         gTypingTargetObject.dataHandle = 0;
  6410.         
  6411.         /*set up the despatch table for the four standard apple events*/
  6412.         
  6413.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEOpenApplication, (EventHandlerProcPtr)DoOpenApp, noRefCon, false) ;
  6414.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEOpenDocuments,   (EventHandlerProcPtr)DoOpenDocument, noRefCon, false) ;
  6415.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEPrintDocuments,  (EventHandlerProcPtr)DoPrintDocuments, noRefCon, false) ;
  6416.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEQuitApplication, (EventHandlerProcPtr)MyQuit, noRefCon, false) ;
  6417.         
  6418.         /* set up the despatch table for the core AppleEvents for text */
  6419.         
  6420.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEDelete, (EventHandlerProcPtr)DoDeleteEdit,noRefCon, false);
  6421.  
  6422.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECut,    (EventHandlerProcPtr)DoCutEdit,   noRefCon, false);
  6423.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECopy,   (EventHandlerProcPtr)DoCopyEdit,  noRefCon, false);
  6424.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAEPaste,  (EventHandlerProcPtr)DoPasteEdit, noRefCon, false);
  6425.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAESetData,(EventHandlerProcPtr)DoSetData,   noRefCon, false);
  6426.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEGetData,(EventHandlerProcPtr)DoGetData,   noRefCon, false);
  6427.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEGetDataSize,(EventHandlerProcPtr)DoGetDataSize,   noRefCon, false);
  6428.         
  6429.         aevtErr = AEInstallEventHandler( kAECoreSuite, kAECountElements,   (EventHandlerProcPtr)HandleNumberOfElements,   noRefCon, false);
  6430.         aevtErr = AEInstallEventHandler( kAECoreSuite, kAECreateElement,   (EventHandlerProcPtr)DoNewElement,   noRefCon, false);
  6431.         aevtErr = AEInstallEventHandler( kAECoreSuite, kAEDoObjectsExist,  (EventHandlerProcPtr)DoIsThereA,   noRefCon, false);
  6432.     
  6433.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEMove,   (EventHandlerProcPtr)DoMoveWindow,noRefCon, false);
  6434.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAEClose,  (EventHandlerProcPtr)DoCloseWindow,noRefCon, false);
  6435.         aevtErr = AEInstallEventHandler( kAECoreSuite,     kAESave,   (EventHandlerProcPtr)DoSaveWindow,noRefCon, false);
  6436.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAERevert, (EventHandlerProcPtr)DoRevertWindow,noRefCon, false);
  6437.         
  6438.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAECreatePublisher,    (EventHandlerProcPtr)HandleCreatePub, noRefCon, false);
  6439.         aevtErr = AEInstallEventHandler( kAEMiscStandards, kAEMakeObjectsVisible, (EventHandlerProcPtr)HandleShowSelection,   noRefCon, false);
  6440.         
  6441.         /* Now look for recording notifications */
  6442.         
  6443.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEStartedRecording, (EventHandlerProcPtr)HandleStartRecording, noRefCon, false);
  6444.         aevtErr = AEInstallEventHandler( kCoreEventClass, kAEStoppedRecording, (EventHandlerProcPtr)HandleStopRecording, noRefCon, false);
  6445.         
  6446.         /* Now Put in the required object accessors */
  6447.         
  6448.         aevtErr = AESetObjectCallbacks(nil,MyCountProc,nil,nil,nil,nil,nil);
  6449.         
  6450.         aevtErr = AEInstallObjectAccessor(cWindow,      typeNull,   WindowFromNullAccessor,  0,false);
  6451.         aevtErr = AEInstallObjectAccessor(cWindow,      typeMyAppl, WindowFromNullAccessor,  0,false);
  6452.                 
  6453.         aevtErr = AEInstallObjectAccessor(cApplication, typeNull,   ApplicationFromNullAccessor,  0,false);
  6454.         aevtErr = AEInstallObjectAccessor(cProperty,    typeMyAppl, PropertyFromApplAccessor,0,false);
  6455.         
  6456.         aevtErr = AEInstallObjectAccessor(cChar,             typeMyWndw,TextElemFromWndwAccessor,0,false);
  6457.         aevtErr = AEInstallObjectAccessor(cSpot,             typeMyWndw,TextElemFromWndwAccessor,0,false);
  6458.         aevtErr = AEInstallObjectAccessor(cWord,             typeMyWndw,TextElemFromWndwAccessor,0,false);
  6459.         aevtErr = AEInstallObjectAccessor(cLine,             typeMyWndw,TextElemFromWndwAccessor,0,false);
  6460.         aevtErr = AEInstallObjectAccessor(cProperty,   typeMyWndw,PropertyFromWndwAccessor,0,false);
  6461.     
  6462.         aevtErr = AEInstallObjectAccessor(cProperty,     typeMyText,PropertyFromTextAccessor,0,false);
  6463.         aevtErr = AEInstallObjectAccessor(cChar,           typeMyText,TextElemFromTextAccessor,0,false);
  6464.         aevtErr = AEInstallObjectAccessor(cWord,           typeMyText,TextElemFromTextAccessor,0,false);
  6465.         aevtErr = AEInstallObjectAccessor(cSpot,           typeMyText,TextElemFromTextAccessor,0,false);
  6466.         aevtErr = AEInstallObjectAccessor(cLine,           typeMyText,TextElemFromTextAccessor,0,false);
  6467.         
  6468.         aevtErr = AEInstallObjectAccessor(cMenu,           typeNull,       MenuFromNullAccessor,    0,false);
  6469.         aevtErr = AEInstallObjectAccessor(cProperty,   typeMyMenu,     PropertyFromMenuAccessor,0,false);
  6470.         aevtErr = AEInstallObjectAccessor(cProperty,   typeMyMenuItem, PropertyFromMenuItemAccessor,0,false);
  6471.         aevtErr = AEInstallObjectAccessor(cMenuItem,   typeMyMenu,     MenuItemFromMenuAccessor,0,false);
  6472.         /* Now the coercion handlers */
  6473.  
  6474.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyAppl,      (ProcPtr)CoerceObjToAnything,0,true,false);
  6475.         aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyWndw,      (ProcPtr)CoerceObjToAnything,0,true,false);
  6476.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyText,      (ProcPtr)CoerceObjToAnything,0,true,false);
  6477.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyTextProp,  (ProcPtr)CoerceObjToAnything,0,true,false);
  6478.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyWindowProp,(ProcPtr)CoerceObjToAnything,0,true,false);
  6479.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyApplProp,  (ProcPtr)CoerceObjToAnything,0,true,false);
  6480.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenu,      (ProcPtr)CoerceObjToAnything,0,true,false);
  6481.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuProp,  (ProcPtr)CoerceObjToAnything,0,true,false);
  6482.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyMenuItem,  (ProcPtr)CoerceObjToAnything,0,true,false);
  6483.       aevtErr = AEInstallCoercionHandler(typeObjectSpecifier,typeMyItemProp,  (ProcPtr)CoerceObjToAnything,0,true,false);
  6484.         
  6485.         /*now install the appropriate edition manager events*/
  6486.         
  6487.         aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionReadMsgID,   (EventHandlerProcPtr)DoReadSection, noRefCon, false) ;
  6488.         aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionWriteMsgID,  (EventHandlerProcPtr)DoWriteSection, noRefCon, false) ;
  6489.         aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionScrollMsgID, (EventHandlerProcPtr)DoScrollSection, noRefCon, false) ;
  6490.         aevtErr = AEInstallEventHandler( sectionEventMsgClass, sectionCancelMsgID, (EventHandlerProcPtr)DoCancelSection, noRefCon, false) ;
  6491.         
  6492.  } /* InitAppleEvents */
  6493.